feat: implement application management system

Add structured workflow for managing job applications with /new-application and /populate-application commands. Users can now organize applications in dated folders, store job documents, and have AI analyze requirements to populate strategy documents. Includes bug fix for src/ path references and safe update documentation.

OpenSpec: add-application-management

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
2025-11-02 19:04:49 +01:00
co-authored by Claude
parent 751af9e310
commit f1ba0dd98d
9 changed files with 1263 additions and 18 deletions
+131 -17
View File
@@ -57,6 +57,87 @@ Please review carefully and manually replace any placeholders before sending to
**Default behavior**: ALWAYS validate unless explicitly told to skip.
## Application Management
The framework provides a structured system for managing individual job applications. Each application gets its own workspace with organized folders for documents and strategy.
### Creating a New Application
Use `/new-application` to initialize a new job application:
```
/new-application "Company Name - Job Title"
```
This will:
1. Create a dated folder: `applications/pending/YYYY-MM-DD-CompanyName-JobTitle/`
2. Generate an `application.md` template with sections for research, strategy, and planning
3. Create an `input/` folder for storing job-related documents
**Example**:
```
/new-application "TechCorp - Senior Developer"
```
Creates: `applications/pending/2025-11-02-TechCorp-Senior-Developer/`
### Adding Input Documents
After creating an application, add all relevant documents to the `input/` folder:
**Recommended documents**:
- Job posting/advertisement (PDF, TXT, MD, DOCX)
- Recruiter emails or communications
- Company research notes (from website, LinkedIn, Glassdoor)
- Follow-up emails or additional context
- Application requirements or instructions
**Supported formats**: PDF, TXT, MD, DOCX, HTML, EML
The more context you provide, the better the analysis will be.
### Populating the Application
Once you've added documents to the `input/` folder, navigate to the application directory and run:
```
cd applications/pending/[your-application-folder]/
/populate-application
```
This will:
1. Read and analyze all documents in the `input/` folder
2. Extract job requirements, company information, and keywords
3. Read your `profile.md` to understand your background
4. Match your experience and skills to the job requirements
5. Populate `application.md` with:
- Extracted job information
- Company research and culture insights
- Match strategy (which experiences/skills to emphasize)
- Key messages to convey
- Tone recommendations
- Suggested projects and achievements to highlight
**The population preserves any manual notes you've added** - it merges AI analysis with your insights.
### Working with application.md
After population, review and refine the `application.md` file:
- **Review extracted information**: Ensure job details and requirements are accurate
- **Add your insights**: Enhance the strategy with your own thoughts
- **Adjust match strategy**: Fine-tune which experiences and projects to emphasize
- **Add personal notes**: Document your authentic reasons for interest in the role
- **Plan your approach**: Use the document checklist to track what needs to be created
The `application.md` serves as your strategic planning document for the entire application process.
### Re-populating Applications
You can run `/populate-application` multiple times:
- Add more documents to `input/` folder
- Re-run to merge new analysis with existing content
- Manual notes are always preserved
## When to Read the Profile
Read `profile.md` automatically when the user asks for help with:
@@ -71,31 +152,49 @@ Read `profile.md` automatically when the user asks for help with:
## Job Application Workflow
When helping with job applications, follow this workflow:
When helping with job applications, follow this comprehensive workflow:
### 0. Profile Validation (REQUIRED FIRST STEP)
- Run `/validate-profile` to check `profile.md` is complete
- If validation fails, stop and ask user to complete profile
- If validation passes or user explicitly skips, proceed to step 1
### 1. Research & Context
- Read the job description provided by the user
- Extract key requirements, skills, and keywords
- Analyze the company culture from the job posting language
- Read `profile.md` to understand what the applicant brings
### 1. Initialize Application (NEW)
- Use `/new-application "Company - Job Title"` to create organized workspace
- This creates: `applications/pending/YYYY-MM-DD-Company-JobTitle/`
- Workspace includes `application.md` template and `input/` folder
### 2. Match & Strategy
- Identify which of the applicant's experiences (from `profile.md`) best match the job requirements
- Determine which skills and projects to emphasize
- Decide on the appropriate tone (formal, balanced, or casual) based on company culture
### 2. Gather Documents & Context (NEW)
- User adds documents to `input/` folder:
- Job posting/description
- Recruiter communications
- Company research
- Any other relevant context
- More context = better analysis and strategy
### 3. Content Generation
- Generate CV/cover letter/email based on the strategy
### 3. Analyze & Populate (NEW)
- Navigate to application folder: `cd applications/pending/[folder-name]/`
- Run `/populate-application` to:
- Read and analyze all input documents
- Extract job requirements, keywords, company culture
- Cross-reference with `profile.md`
- Generate match strategy
- Populate `application.md` with research and recommendations
### 4. Review & Refine Strategy
- User reviews `application.md` for accuracy
- User adds personal insights and authentic motivations
- Adjust which experiences and projects to emphasize
- Fine-tune key messages and tone
### 5. Content Generation (FUTURE)
- Generate CV/cover letter/email based on `application.md` strategy
- Emphasize relevant experience from `profile.md`
- Incorporate keywords from the job description naturally
- Maintain factual accuracy - use only verified information from `profile.md`
- **Note**: Document generation will be implemented in a future update
### 4. Quality Assurance
### 6. Quality Assurance
- Verify all company names, dates, and facts are correct
- Ensure consistency between all documents (CV ↔ cover letter ↔ email)
- Check that tone matches the target company culture
@@ -154,10 +253,26 @@ Adjust recommendations based on the target market if the user specifies a differ
## Available Commands
- `/validate-profile` - Validate that `profile.md` is complete and ready for application generation
- `/new-application "Company - Job Title"` - Create a new application workspace with organized folder structure
- `/populate-application` - Analyze input documents and populate application.md with job info, research, and strategy
## Example Usage
**User**: "Help me apply for this software engineering position at TechCorp [paste job description]"
### Example 1: Complete Application Workflow
**User**: "Help me apply for this software engineering position at TechCorp"
**Claude Code should**:
1. Run `/validate-profile` to check profile completeness
2. If validation passes, suggest: "Let's create an application workspace. Run: `/new-application 'TechCorp - Software Engineer'`"
3. After application is created, guide user: "Add the job posting and any other documents to `applications/pending/[folder]/input/`"
4. When user has added documents: "Navigate to the application folder and run `/populate-application`"
5. After population completes: "Review `application.md` to see the analysis and strategy"
6. Future: Generate tailored CV, cover letter, and email based on `application.md`
### Example 2: Quick Document Request (Legacy Flow)
**User**: "Write a cover letter for this role [paste job description]"
**Claude Code should**:
1. Run `/validate-profile` to check profile completeness
@@ -165,9 +280,8 @@ Adjust recommendations based on the target market if the user specifies a differ
3. If validation passes: Read `profile.md` to load applicant information
4. Analyze the job description for requirements and culture
5. Identify matching experiences and skills from the profile
6. Ask clarifying questions: "Would you like me to create a CV, cover letter, or both?"
7. Generate tailored documents using only information from `profile.md`
8. Ensure all documents are consistent and factually accurate
6. Generate tailored cover letter using only information from `profile.md`
7. Suggest: "For better organization, consider using `/new-application` next time to manage the full application process"
## Updating the Profile