Folio

Here’s a job search workflow I designed for experienced software engineers in 2026: built on top of Claude Projects, structured around source documents and decisions that actually move a search forward.

The guide below walks through how to set it up for yourself.

What Is Folio?

Folio is a Claude Project configured as a Staff-level Career Strategist and Technical Writer. The idea: load it with your complete professional history once, then use it as a filter; surfacing the right content for any specific role, JD, or recruiter conversation, without starting from scratch every time.

What it does:

• Interviews you to build structured career documents
• Scores inbound opportunities against your parameters and maintains a living pipeline stackrank
• Generates targeted resume outlines per role, not generic PDFs
• Guides cold outreach qualification, interview prep, and negotiation
• Evolves as your search and history grow

What it doesn’t do:

• Replace a human editor or career coach
• Guarantee interview outcomes
• Know things you haven’t told it

Part 1 — Project Setup

1.1 Create the Claude Project

• Go to Claude.ai → Projects → New Project
• Name it whatever you’d like; it’ll be referenced as Folio throughout this guide
• Open Project Instructions and paste the system prompt below (with any modifications you’d like)

1.2 System Prompt

You are a Staff-Level Career Strategist and Technical Writer for an experienced
software engineer conducting a targeted job search.

Your purpose is to ingest a "Super Resume" and act as a filter — providing
targeted outlines, content recommendations, and structural guidance for
specific roles or JDs. You do not generate final PDFs or Word documents.

Core behavior:
- Index experience by: tech stack, leadership level, and project impact
- Prioritize high-competency/recent items that align to the target role
- Tone: professional, analytical, direct — no filler, no buzzwords
- Format: Markdown, bulleted lists, high scannability
- Never include home addresses, private phone numbers, or proprietary secrets
- Ask one clarifying question at a time when running interview flows
- When given a JD, always: flag mismatches, filter bullets, surface keywords,
  recommend project framing, and suggest section order

When the candidate says "outline for [Company]", run the full targeting flow.
When the candidate says "interview prep for [Company]", run the prep flow.
When the candidate says "cold outreach from [Company]", run the qualifier flow.

When the candidate provides a JD and asks to evaluate it against their parameters:
- Present a hard blockers table (comp, remote, level, stack, stage)
- List soft flags with severity notes
- Score JD fit 0–10 with dimension-by-dimension rationale
- Recommend: proceed / qualify first / decline / defer / treat as practice rep
- Update pipeline stackrank in memory when instructed

When the candidate says "capture stackrank in project memory", update the
running pipeline ranking with the new role at the appropriate position.

Part 2 — Core Project Files

These are the documents Folio needs to do its job. Some you gather; others you generate via interview. All should be added to the project’s Knowledge tab once created.

2.1 File Map

Note on the pipeline stackrank: The living stackrank (rank-ordered list of all active opportunities) lives in Folio’s project memory, not in a file. This lets it update in real time across chats as new roles arrive. pipeline.md tracks per-role status details (stage, last action, next step); the memory-based stackrank tracks relative priority order. Both are maintained separately.

2.2 Per-Application Files (Ephemeral)

Don’t add these permanently to the project. Attach them inline to individual chats.

Part 3 — Job Parameters Interview

Run this in a fresh Folio chat to generate your jobParameters.md file.

3.1 Prompt to Start

I need to build a jobParameters file that will inform all my resume targeting,
outreach filtering, and role assessments going forward.

Interview me one topic at a time to capture:
- Location and remote/hybrid preferences
- Commute constraints and acceptable office cadence
- Target level and title
- IC vs. management preference
- Preferred company stage and size
- Industry preferences and exclusions
- Target tech stack and what I'm not interested in
- Compensation floor (base, equity expectations, benefits must-haves)
- Recruiter preferences (in-house vs. agency, how I like to engage)
- Hard blockers (things that auto-disqualify a role)

After the interview, output the result as a structured Markdown file
I can save as jobParameters.md and add to my project.

3.2 Key Topics to Cover

• Location — home base, remote preference, hybrid cadence limit, travel tolerance
• Level — target title(s), and whether you’d consider one level down with the right comp/scope
• Stage — seed / Series A / Series B–C / growth / public; which you’d rule out
• Industry — what excites you, what you’d avoid, any domain experience to leverage
• Stack — primary targets, what you’ll learn, what you won’t touch
• Comp — base floor, equity expectations (startup options vs. RSUs vs. “nice to have”), benefits non-negotiables
• Blockers — on-site only, below-floor comp, pure backend, management track, etc.
• Recruiter etiquette — how early you want comp visibility, agency vs. in-house preference

Save the output as jobParameters.md and upload to your project Knowledge.

Part 4 — Super Resume Interview

Your Super Resume is the master document Folio draws from when tailoring content. It should be exhaustive, more than any resume would ever show.

4.1 Prompt to Start

I need to build a Super Resume — a comprehensive document of my entire
professional history that you'll use to generate targeted resume content.

Interview me one role at a time, starting with my most recent. For each role, ask:
1. Company, title, dates, team size, product context
2. Stack and tools I owned vs. used vs. touched
3. What I built or owned end-to-end
4. Biggest technical decisions or tradeoffs I made
5. Measurable impact — technical, business, team, or customer
6. What I'm most proud of from that role
7. What I'd frame or do differently in hindsight

After covering all roles, ask about:
- Side projects with public links or demos
- Open source contributions
- Technical writing, talks, or docs
- Education and any relevant coursework or research

Output the final result as a structured Markdown file I can save as superResume.md.

4.2 Tips

• Include internal project names with a plain-English translation; Folio will know to omit internal names in public-facing content
• Don’t self-edit during the interview; more detail is always better at this stage
• Revisit and update the file after major launches or role changes

4.3 Building Your Anchor Story Bank

After completing the Super Resume, extract a named bank of 6–8 key stories. These get referenced by name across every interview prep session, so having consistent shorthand matters.

What makes a good anchor story:

• End-to-end ownership: you drove it from ambiguous problem to shipped solution
• Specific tradeoffs: decisions made, things deprioritized, why
• Measurable or observable impact
• Covers at least one of: technical depth, cross-functional complexity, greenfield initiative, or scale

Prompt to generate the bank:

Based on my superResume, identify 6–8 anchor stories I should have
ready for any engineering interview. For each:
- Give it a short reference name (e.g., "SearchRebuild", "NotifService")
- Summarize the problem → contribution → outcome in 3 bullets
- Note which interview themes it maps to (e.g., system design,
  end-to-end ownership, cross-functional collab, greenfield/0→1,
  AI/LLM integration, speed and iteration)

These story names become shorthand throughout Folio. When prepping for a screen, you’ll ask Folio to map “anchor stories” to the company’s interview themes; it will reference them by name.

Part 5 — Brag Doc

A brag doc is an ongoing timestamped log of shipped work, received praise, and impact moments. It feeds your Super Resume updates, performance reviews, and resume bullet refreshes.

5.1 Format

## [Year] Q[N] — [Month Range]

- [Tag] — brief description of what shipped or happened
- [Tag] — ...

## [Year] Q[N] — ...

Tags: UI, API, Infra, Docs, DX, Collab, Leadership, Feedback received

5.2 Interview to Seed It

If starting from scratch:

Help me build a brag doc for the past 2 years. Ask me quarter by quarter.
For each quarter, ask:
- What shipped that I was directly responsible for?
- What problems did I solve that weren't in my original scope?
- What positive feedback did I receive, and from whom?
- What did I teach, document, or improve that others benefited from?

Format the output as a quarterly brag doc in Markdown.

5.3 Ongoing Maintenance

• Log entries weekly, even one line — recency fades fast
• Before any performance review or active application push, run:

  Summarize my brag doc into my top 5 accomplishments with impact framing,
  calibrated for a Staff-level IC.
  

Part 6 — Performance Feedback

Collecting and indexing your received feedback — across roles — surfaces impact language and reveals patterns you can use in interviews, cover notes, and self-assessments.

6.1 What to Include

• Formal performance review notes (self or manager)
• 360 feedback excerpts
• Slack/email praise (especially from cross-functional partners or leadership)
• Retrospective callouts
• Peer review comments

6.2 If You Have Existing Notes

I have performance feedback from several roles I'd like to add to my project.
I'll paste them in. For each one:
1. Extract the key themes (strengths + growth areas)
2. Note the source type (manager, peer, self, etc.) and approximate date
3. Flag any recurring patterns across multiple pieces of feedback
4. Identify language I should carry into my resume bullets or interview stories

After processing all of them, output a summary as perfFeedback.md.

6.3 If Starting From Memory

Help me reconstruct my historical performance feedback via interview.
Ask me about one role at a time, covering:
- What did managers or peers consistently praise me for?
- What were the growth areas or critiques I received?
- Were there any specific incidents — positive or negative — that generated feedback?
- What did I write about myself in self-reviews, and do I still agree?

Output the result as perfFeedback.md.

Part 7 — Network & Connections

Your network is a long-term asset. This file tracks people worth staying connected with — both for the current search and future ones.

7.1 Categories to Track

• Former colleagues — people you’d work with again in any context
• Managers / advocates — people who know your work well and would speak to it
• Target company contacts — people currently at companies you’d consider
• Recruiters (trusted) — in-house or agency recruiters with good track records

7.2 File Format

## [Name] — [Current Company / Role]

- **Relationship:** [how you know them, when you worked together]
- **Why valuable:** [what they'd say about you, or what access they have]
- **Last contact:** [approximate date or context]
- **Reconnect strategy:** [specific angle — congratulate a promotion, share an article, ask for coffee, etc.]
- **Status:** [active / dormant / pending]

7.3 Interview to Seed It

Help me build a connections list for my job search.
Ask me about each phase of my career and prompt me to recall:
- Who did I work closely with and respect?
- Who has gone on to interesting companies or roles?
- Who would give me a strong reference without hesitation?
- Who is currently at a company I'd want to work at?
- Who are the recruiters I've had good experiences with?

For each person I name, help me draft a reconnect strategy.
Output the result as connections.md.

7.4 Reconnect Principles

• Lead with genuine context: a shared project, a recent announcement, a congratulation
• Never open with “I’m job searching”; establish the relationship first
• Short asks are better than long ones; a coffee chat beats a phone call request
• Update connections.md after every interaction

Part 8 — AI Tool Assessment

AI fluency is increasingly a signal in Staff+ interviews. This section helps you audit your current usage, identify gaps, and develop talking points.

8.1 Interview to Seed It

Help me assess my current AI tool usage and identify gaps.
Ask me:
1. Which AI tools do I use today, and in what contexts?
2. How deeply am I using each — occasional chat vs. integrated into daily workflow?
3. Which tasks have I genuinely accelerated or improved with AI?
4. Where have I tried AI and found it lacking or not worth the friction?
5. Are there areas of my workflow where I haven't tried AI but probably should?
6. How do I currently talk about AI tool usage in interviews or conversations?

After the interview:
- Summarize my current AI fluency profile
- Flag 2–3 specific gaps or opportunities to level up
- Draft talking points for how to discuss AI in interviews
Output as aiAssessment.md.

8.2 Common Tools to Evaluate

8.3 How to Talk About AI in Interviews

Good framing:

• Specific use cases: “I use Claude Code for step-by-step refactoring on unfamiliar codebases” (replace with your actual tool and workflow)
• Judgment signals: “I’ve found AI useful for X but I still prefer to Y manually because…”
• Learning posture: “I’ve been experimenting with Z and here’s what I’ve learned”

Avoid:

• Vague claims: “I use AI tools regularly”; says nothing
• Overclaiming: suggesting AI wrote your code or drove your decisions
• Underclaiming: pretending you don’t use it at all

When evaluating a specific role, ask Folio to flag any AI/LLM experience gaps relative to the JD, and to suggest which anchor stories or current usage patterns best address them.

8.4 Leveling Up Before a Search

• Pick one tool you underuse and spend a focused week integrating it into real work
• Build or improve something with AI assistance and be able to describe the process concretely
• Follow 2–3 engineers writing about AI workflows (newsletters, GitHub, substack); gives you current vocabulary

Part 9 — LinkedIn Optimization

9.1 Export Your Profile First

LinkedIn → Settings → Data Privacy → Get a copy of your data → Request archive. Use the profile text to populate linkedInProfile.md in your project.

9.2 Headline

Format: [Level] Software Engineer · [Stack] · [Differentiator]

• Keep under 220 characters
• Include your most searchable stack terms
• Add a differentiator that’s not just “passionate” — e.g., a domain, a craft, an output type

9.3 About Section

Three-paragraph structure:

1. What you are — level, years, core stack, domain focus
2. What you’ve built — 2–3 concrete examples with scale or impact signals
3. What you’re looking for — role type, stage, what energizes you (if open to opportunities)

Generate my LinkedIn About section based on my superResume and jobParameters.
Three short paragraphs. No buzzwords. Lead with stack and domain.
Include 2–3 impact examples. End with what kind of role I'm targeting.

9.4 Experience Bullets

Per role: 3–5 bullets max. Rules:

• Lead with an action verb + outcome
• At least one bullet with a stack signal
• At least one bullet with a scale or impact signal
• No internal codenames that mean nothing outside the company

Rewrite my [Company] experience as 4 LinkedIn bullets.
No internal project names. Lead with impact. Include relevant stack.
Reference my superResume for source material.

9.5 Featured Section

• Pin your portfolio/personal site (if you have one — see Part 12)
• Pin a side project with a live demo link
• Pin a technical post or doc if you’ve published one

9.6 Skills Section

• Reorder top 3 to match your target stack — these are most visible
• Remove stale skills you couldn’t interview on today
• Get endorsements from trusted former colleagues on your core 5–6 skills

Part 10 — Wellfound + Other Platforms

10.1 Wellfound (AngelList) — for Startups

• Build or sync your profile; set Job Preferences explicitly
• Enable Open to Opportunities with your comp floor visible: this filters noise before it reaches you
• Write a short “What I’m looking for” note in your profile; founders read these
• Emphasize startup-relevant angles: greenfield ownership, small team, end-to-end scope
• YC Work at a Startup is a useful companion for YC-backed seed/Series A roles

10.2 Platform Guide

10.3 General Platform Hygiene

• Keep comp floor consistent across all platforms — inconsistency invites lowball anchoring
• Update availability status after accepting an offer — don’t leave platforms showing open
• Check messages weekly minimum; inbound goes stale fast

Part 11 — Resume Strategy

11.1 Variants to Maintain

The three variants below assume a fullstack-leaning baseline — adjust the labels and emphasis to match your own primary strengths. A backend-primary engineer, for example, would invert the framing: Backend/API-Leaning becomes the default, and Frontend-Leaning becomes the stretch variant.

All three pull from the same superResume.md. Folio filters and reorders for you.

11.2 Resume Structure

[Name] · [City, State] · [Email] · [LinkedIn URL] · [Portfolio URL]

SUMMARY (optional — 2–3 lines; useful for ATS; omit if your experience speaks clearly)

EXPERIENCE
  [Company] — [Title] — [Start]–[End]
  · [Bullet: action verb + outcome + scale/stack signal]
  · [Bullet]
  · [Bullet]
  (3–5 bullets per role; more recent roles get more bullets)

PROJECTS (include if relevant to the role)
  [Project Name] — [stack] — [link if public]
  · [One-line impact or what makes it worth including]

SKILLS
  Languages:  TypeScript, Python, SQL
  Frontend:   React, [UI framework], [viz library]
  Backend:    [API tech], [ORM], [runtime]
  Infra:      [Cloud provider], [services used]
  Tooling:    [CI/CD], [monitoring], [project tools]

11.3 Generating a Targeted Outline

I'm applying to [Company] for their [Role Title] position.
JD is attached. Generate a resume outline:
1. Suggested section order for this role
2. Top 5–7 bullets from my superResume that best prove fit
3. Keywords I must include (technical + soft skills)
4. Which projects to feature and how to frame them
5. Skills/tools list filtered to what's relevant
Flag any gaps between my experience and the JD requirements.

11.4 Resume Diffs Over Full Rewrites

Once you have a working base resume for a variant, subsequent role-specific tailoring works better as a patch diff than a full rewrite. A diff specifies only what changes — additions, deletions, and rewrites at the bullet level — making it easy to cross-reference against your current resume without re-typesetting the whole document.

Prompt to generate a diff:

I have an existing resume for the [Variant] track. I'm tailoring it for
[Company] / [Role]. Using patch-diff format, suggest only the changes
needed — additions, deletions, and rewrites at the bullet or section level.
Don't regenerate content that doesn't need to change.

Diff format:

- Old bullet or section content
+ New bullet or section content

For reordering (no text change), call it out separately:

Reorder: move [Bullet X] above [Bullet Y] in the [Company] section.

Final pass: Once diffs are applied, paste the relevant sections and ask for a final pass confirmation before sending:

Here's the updated [section / full resume]. Final pass — any remaining issues?

Folio will flag typos, formatting inconsistencies, weak framing, or bullets that don’t land for this specific JD. When everything is clean: Ship it.

11.5 Anti-Patterns to Avoid

• Bullets that describe responsibility instead of impact (“responsible for X” → “built/shipped/reduced/improved X”)
• Internal codenames with no external translation
• Skills you couldn’t discuss comfortably in a 15-minute screen
• GPA, references available upon request, or photos
• More than 2 pages for 10+ years of experience
• One-size-fits-all resumes; always variant-target before sending

Part 12 — Portfolio Site

12.1 Why Bother?

• Gives recruiters and hiring managers something to reference between your resume and the interview
• Demonstrates that you ship things outside of work
• A live demo or side project carries more weight than a bullet point
• Signals investment in your craft and public presence
• Particularly valuable if your day-job work isn’t publicly visible

12.2 What to Include

12.3 What to Skip

• Lengthy bios or life stories
• Projects without a clear purpose or that are visibly abandoned
• Skill bars or percentage ratings (“95% React”); they signal nothing
• Blog content you haven’t touched in years
• Anything that takes longer than 5 seconds to load

12.4 Generating Content

Help me write the About section for my portfolio site.
4 sentences max. Lead with stack and domain.
Reference my superResume for impact examples.
Tone: direct, no buzzwords, sounds like a person — not a LinkedIn headline.

Part 13 — The Qualifier Flow

This is the most-used pattern in Folio. Run it every time a new opportunity arrives: cold outreach, a JD from a recruiter, or a role you find on your own.

13.1 Standard Prompt

[Attach JD PDF or paste JD text]

Based on my jobParameters:
1. Flag any hard blockers (comp, remote, level, stack, stage)
2. Score this JD fit relative to all other inflight JDs / conversations /
   loops and capture the stackrank in project memory

This single prompt drives: blocker analysis, fit scoring, stackrank update, and a proceed/skip recommendation.

13.2 Hard Blockers vs. Soft Flags

Hard blockers auto-disqualify. If any are present, Folio recommends a decline or deferral. Common hard blockers:

Soft flags require qualification before proceeding. They slow you down but don’t auto-reject. Common soft flags:

When soft flags are present, Folio will surface qualifying questions to ask the recruiter before investing further.

13.3 JD Fit Score

Every evaluated role gets a 0–10 fit score with rationale across key dimensions (stack, level, domain, comp, location). The score reflects how well the role maps to your background and parameters — not how much you want it.

The fit score is separate from pipeline rank. A role can be fit 8/10 but rank #6 if it’s early in process and five other roles are further along.

13.4 Decision Framework

After the qualifier flow, Folio recommends one of five actions:

Practice reps are a deliberate strategy. Accepting a screen for an imperfect-fit role has standalone value: interview rustiness, story delivery, real-time calibration on how you come across, and a chance to identify gaps you can address before higher-priority loops. Label them explicitly so you don’t over-invest.

13.5 Batch Evaluation

When a recruiter sends multiple JDs at once, paste them all in a single chat and ask Folio to evaluate the batch:

[Attach or paste multiple JDs]

Evaluate this batch against my jobParameters:
1. Flag hard blockers for each
2. Rank them against each other by JD fit
3. Note which are worth pursuing vs. skipping
Do not update the stackrank yet — I'll confirm after reviewing.

Review the batch assessment, then ask for the stackrank update once you’ve decided which to pursue.

Part 14 — Pipeline Stackrank

The stackrank is a living, memory-based rank-ordering of all active opportunities by priority. It updates with every new role that enters or exits the pipeline.

14.1 Two Types of Rankings

Folio maintains two distinct rankings. Keep them separate:

A role can be fit 9/10 but rank #3 because two others are in final rounds. A role can be fit 5/10 but rank #1 if it’s the only one at offer stage.

14.2 Seeding the Stackrank

After running qualifier flows on your first 3–5 roles:

I've evaluated [Role A], [Role B], and [Role C]. Based on the qualifier
assessments, set the initial pipeline stackrank in project memory.
Include: company, role title, brief status note, and fit score for each.

14.3 Updating the Stackrank

The standard qualifier prompt (Part 13.1) includes capture stackrank in project memory — this triggers a stackrank update automatically. When a role advances, stalls, or exits, update manually:

[Company] has moved to [new stage]. Update the pipeline stackrank
and note [any context].

14.4 Sub-Pipelines

When a single recruiter manages multiple roles, track them as a sub-pipeline alongside the main stackrank. This is useful when the same contact is your channel for several companies — knowing their full slate helps you negotiate priority and manage the relationship.

[Recruiter name] / [Agency] sub-pipeline:
(1) [Company A] — [role, comp, fit notes]
(2) [Company B] — [role, comp, fit notes]

14.5 Pipeline Review

Run a weekly pipeline review prompt to surface stalls, overdue follow-ups, and priority shifts:

Here's my current pipeline stackrank: [paste or ask Folio to recall from memory]
1. What follow-ups are overdue?
2. Which threads have gone quiet — re-engage or close?
3. What's my highest-priority active thread?
4. Any patterns across stalls or rejections I should address?

Part 15 — Handling Cold Outreach

15.1 Before You Reply

Open a Folio chat, attach or paste the recruiter message, then run the qualifier flow (Part 13):

[Paste recruiter message or attach email]

Based on my jobParameters:
1. Flag any hard blockers (comp, remote, level, stack, stage)
2. If no blockers: draft a short qualifying reply that surfaces my comp
   floor and remote preference early without over-committing
3. If blockers: draft a polite decline or deferral
4. Score fit and capture in pipeline stackrank if worth tracking

15.2 Reply Templates

Interested — no visible blockers:

Thanks for reaching out — sounds interesting. Could you share the full JD
and any comp range context? I'm targeting [level] IC roles, remote-preferred,
with a [floor] base. Happy to connect once I've had a chance to review.

Comp too low:

Appreciate you thinking of me. Based on the range mentioned, I don't think
we're aligned on comp right now — I'm targeting [floor]+. If that changes
or a higher-band opening comes up, happy to reconnect.

Role mismatch (level / stack / location):

Thanks for the note. Based on the description, I don't think this is the
right fit — [specific reason]. Worth keeping in touch if something more
aligned comes up.

15.3 Recruiter Relationship Context

Different recruiter types warrant different protocols:

Never volunteer your comp floor unprompted to a recruiter. Use publicly posted ranges and job board salary data as anchors instead.

Part 16 — Per-Application Workflow

16.1 Pre-Apply Checklist

• JD saved as PDF or text
• Company stage, team size, and recent funding noted
• LinkedIn: check if any connections are currently there
• Glassdoor / Levels.fyi: comp signals checked
• Any referral path identified and activated before applying cold
• Qualifier flow run; hard blockers cleared

16.2 Starting the Application Chat

Attach: JD PDF + recruiter email thread (if applicable), then:

I'm applying to [Company] for [Role Title].
JD attached. [Recruiter email attached if applicable.]

1. Flag any hard mismatches vs. my jobParameters
2. Generate a tailored resume outline (section order, top bullets, keywords)
3. Map my anchor stories to the likely interview themes for this role
4. Flag which projects to feature and how to frame them
5. Note anything I should research or prep before a screen

16.3 Story Mapping

For every application, Folio maps your anchor story bank to the specific themes the role is likely to probe. This gives you a prioritized prep list rather than reviewing all your experience from scratch.

Common interview theme buckets:

16.4 Company and Hiring Manager Research

Before any screen — especially HM or founder — research:

• Product: what’s the core value prop; what’s in the current roadmap if available
• Hiring manager: LinkedIn, prior roles, any public writing or talks
• Recent news: funding rounds, product launches, press mentions
• Stack signals: job postings, engineering blog, GitHub if public
• Competitive context: who else is in the space; how does this company differentiate

Research [Company] and [Hiring Manager name] for my upcoming [screen type].
Summarize: product and current direction, HM background and what to know
about them, recent company news, and 2–3 questions I should ask.

Note: If your Claude plan includes web search, Folio can run this research live in the same chat. If not, gather the context manually and paste it in — the summary prompt works either way.

16.5 Practice Rep Framing

If you’ve flagged a role as a practice rep (Part 13.4), be explicit in your prep:

I'm treating [Company] as a practice rep — fit is ~[X/10].
Help me identify which interview skills to focus on practicing here
(e.g., story delivery, technical depth on [topic], system design framing)
rather than optimizing for this specific JD.

This shifts prep from “how do I land this role” to “what do I improve by doing this loop.”

16.6 Interview Prep

I have a [screen type: recruiter / hiring manager / technical / system design]
interview at [Company] for [Role].

Based on my anchor stories and their JD:
1. Which 3–5 stories best map to what they're likely to ask?
2. What questions should I prepare to ask them?
3. What gaps or weaknesses might come up, and how should I address them?
4. Any company-specific context I should research before the call?

Part 17 — Negotiation Guidance

17.1 General Principles

• Never accept or decline on the call; always ask for time to review
• Get the full offer in writing before negotiating anything
• Negotiate the full package, not just base; levers exist across all components
• One counteroffer is standard; two is possible with strong justification; three strains goodwill

17.2 Base Salary

Counter framing:

Thank you for the offer — I'm genuinely excited about the role. Based on my
[X years of experience / specific skill / competing interest], I was hoping
we could get to [target]. Is there flexibility there?

17.3 Equity

Ask: “What does the equity look like as a percentage of fully diluted shares?” — more useful than raw grant size.

17.4 Benefits and Other Levers

Don’t leave these on the table if base is maxed out:

• Sign-on bonus — often easier to unlock than base; ask specifically if base is stuck
• Start date — negotiating extra transition time can be worth real money (PTO payout, vesting cliff, bonus cycle)
• PTO / leave policy — especially relevant at startups with undefined or “unlimited” PTO
• Remote equipment stipend — standard at most remote-first companies; ask if not offered
• Learning / conference budget — signals investment in your growth; negotiate into offer letter
• Equity acceleration — ask about single vs. double trigger acceleration on acquisition

17.5 Competing Offer Leverage

• Always honest; fabricated competing offers backfire badly
• If real: share the existence but not always the exact number
• Use it to accelerate timelines, not just inflate comp: “I have another offer I need to respond to by [date]“

Part 18 — Reference Strategy

18.1 Who to Select

Strong references share three properties:

• They have direct, recent visibility into your work
• They can speak to specific impact, not just general praise
• They’re credible to the hiring company — title, company, or domain matter

Ideal mix:

• 1 former direct manager
• 1 cross-functional collaborator (PM, data, design, ops)
• 1 senior peer or skip-level who saw your work closely

18.2 Interview to Build Your Reference List

Help me identify and prepare my reference list.
Ask me:
1. Who are the managers I've worked for who know my work best?
2. Who are the peers or cross-functional partners who've praised my work directly?
3. Are there any senior leaders who have visibility into specific projects?
4. For each person: how recently did we work together, what would they say,
   and is there any risk of a mixed or lukewarm reference?

After the interview, help me rank the list and draft a prep note for each reference.

18.3 How to Prep Your References

Contact each reference before they’re called:

• Let them know you’re actively searching
• Share the JD and company context for the role they’re being asked about
• Remind them of 1–2 specific projects or moments you’d want them to emphasize
• Give them an out — “only if you can speak enthusiastically” — and mean it

Prep note template:

Hey [Name] — I'm in active conversations with [Company] for a [Role] position.
Would you be comfortable being a reference? If so, I wanted to flag a couple
of things that might be relevant: [specific project / impact / moment].
The role is focused on [brief context]. Happy to share the JD if helpful.

18.4 When to Activate References

• Not until final round or offer stage — protect your references’ time
• Give references advance notice before listing them — never surprise them
• Follow up with a thank-you after the process, regardless of outcome
• Refresh the list annually — people change roles, relationships cool

Part 19 — Pipeline Management

The pipeline stackrank (living rank-order by priority) is covered in Part 14. This section covers per-role status tracking.

19.1 Pipeline File Format

Maintain a pipeline.md table for per-role status details:

| Company | Role      | Source   | Fit  | Status            | Last Action           | Next Step   | Notes                  |
| ------- | --------- | -------- | ---- | ----------------- | --------------------- | ----------- | ---------------------- |
| [Co]    | Staff SWE | LinkedIn | 7/10 | HM screen pending | Recruiter screen done | Schedule HM | Stack match, level TBD |

Status values: Applied → Recruiter Screen → HM Screen → Technical → Final → Offer → Closed

The Fit column from the qualifier flow goes here. Keep it consistent with what’s in project memory.

19.2 When to Close a Thread

• No response after 2 follow-ups spaced 5–7 days apart
• Role removed from company’s careers page
• Explicit rejection received
• Offer received and declined — send a gracious close note anyway (network maintenance)

Part 20 — Quick-Start Prompt Reference