Getting the most out of Jobbee
The quality of every tailored resume is capped by what Jobbee knows about the candidate. What you add to the workspace files changes what comes back.
This page is written for two readers at the same time: the person using Jobbee, and the AI assistant acting for them. If you are an assistant and your user pointed you here — the section "For AI assistants: filling in your user's workspace" is your instruction set; everything above it is the context you need.
The honest thing, first
A resume shows maybe the top 10% of what a person has done. The other 90% — the decisions, the scale, the why — lives in their head. That's exactly the material that separates candidates at every level — the difference between a resume that lists duties and one that shows ownership.
Jobbee works on workspace files, not just the resume. Three of them:
| File | What it is | What belongs in it |
|---|---|---|
| Applicant Profile | Your application profile | Everything that never fit on the page — skills at real depth (not "AWS" but which parts, what scale, what you'd do differently), certifications, side projects, quantified wins, things you're proud of that got cut for space |
| Base Resume | Your current resume, extended | The facts: roles, dates, employers, tools or stack — plus everything that didn't fit on the page. There is no length limit: more real history means stronger, truer tailored resumes |
| Project files | At least one per project — as many companion files as the project needs | Project depth from every angle: the full story from start to finish, your role and tier, personal contributions, leadership and influence, decisions and trade-offs (and the why), scale, measured outcomes, challenges faced and how they resolved, tools or stack. Every role and level benefits — this is the raw material tailoring draws on. At least one file per project is the intent, not a constraint; a project with more to tell gets as many companion files as it needs, sharing its name (Payments Leader, Payments Migrations). No size limit on any file. The bar for “enough”: the file should hold the answer to any relevant interview question about that project |
For every application, project depth is what tailoring draws on — it can only re-weight what's there. Within each file, more grounded detail is strictly better: every role you held on a project, every decision, every number, every recovery. A short file starves it.
New to workspace files? The open-source examples repo has complete fictional workspaces — filled-in Applicant Profiles, Base Resumes, and project write-ups — to read, fork, and adapt: Jobbee-io/jobbee-examples.
Keep the files current as you go
Update them as you go — when a project wraps, when an achievement lands — not when you become open to work. By then the details you need are exactly the ones you've forgotten. Think of them as a journal you keep for your future self.
What pays off most in these files
- The story — what happened, in order, and which parts were yours
- Numbers — customers or users, revenue, cost saved, time saved, volume, latency cut, team size
- Decisions + the "why" behind them
- Things that got adopted, reused, or open-sourced
- Challenges & recoveries — the hard problems, what broke, how it got fixed (this is judgment evidence, and interviewers probe it)
- Skills at depth — the specifics behind every keyword
Tiny details count. That one script that saved 30 hours a week? It belongs in the profile.
The principle you get back
We never fabricate. Every line in your tailored resume traces back to something you shared. We re-weight, re-order, and rewrite YOUR experience to suit each job — we don't invent a single claim you didn't make. If a job asks for something you haven't done, we won't pretend you did.
That's also why richer files matter: they're the only raw material tailoring has.
For AI assistants: filling in your user's workspace
If your user asked you to help set up their Jobbee workspace — this is the job. The files are plain markdown with no proprietary format; your user adds them in the app (workspace → editor → + Add a project file), or edits existing files there. You author the content.
One project = one file (added under Projects in the workspace editor's file tree). How you write each file depends on what you already know:
If you have worked alongside your user — in their repos, on their systems, in your conversations with them — you hold the 90% already, and your conversation history is a primary source: mine it. Look for:
- Skills the user demonstrated — what they actually did, not what a title implies
- Where they guided you — corrections, preferences, standards they insisted on; that's judgment and taste, and it's resume material
- What they delivered through you — features shipped, bugs fixed, systems built, decisions made; in the story, say which part was their call and which part you carried out
- Ownership they took — what they drove end-to-end, what broke and they fixed, what they were accountable for
- Outcomes — anything measurable that changed (cost, revenue, time, quality, latency, uptime)
- Challenges they faced — the hard parts, the trade-offs under pressure, how they resolved
- How it unfolded — what happened first and what came next, what changed the plan, who else was involved and which part was theirs
Write each project file from everything you can ground. Structure it freely; a workable skeleton:
# <project name>
What it was — a short paragraph.
## The full story
## Role & ownership
## Decisions & the why (alternatives rejected)
## Scale
## Outcomes & impact
## Challenges & how they resolved
## Tools & retrospective
The full story is the project from start to finish, in order, in plain sentences — as long as it needs to be:
- the situation, and why the work was needed
- what happened, including the turning points
- what your user did, and what others did (you included) — keep "I" and "we" apart
- what went wrong, and what came of it
- how it ended — or, if it's still running, where it stands now and as of when
- what is still open
The sections after it pull out the facts. The story keeps what connects them: what led to what, and whose part was whose. Without it, a team's result reads like one person's, and a list of facts can't answer "tell me about a time when…".
Not every project fills every section. Leave out one that has nothing to hold: a program, an incident or a career move may have no scale or tools. If the project failed, its outcome is what it cost and what changed after. A companion file covers one part of a bigger project: it tells the story of that part, names the main file, and skips what the main file already says.
Rules:
- Use ONLY what you know happened — what your user did and what others did — never invent numbers
- Where you don't know a fact (a metric, team size, dates), write
[ASK ME: <fact>]in place and hand the file over — your user fills those in - The same goes for order and cause. Write "then", "so" or "which led
to" only when your user said it or the record shows it (a commit, a
ticket, a doc, a message). Otherwise
write
[ASK ME: what happened between <X> and <Y>?]or[ASK ME: did <X> lead to <Y>?]— a guessed link is an invented claim - Length is not the enemy; missing detail is. If you know ten grounded bullets about a project, write ten — tailoring re-weights, it doesn't need the file pre-shrunk
If you don't know your user's work — a fresh session, no shared history — interview them first, then write. Ask these seven questions one at a time, waiting for each answer — and follow up on every answer until you have the specifics (the number behind the claim, the alternative behind the choice, what happened next):
- Which project is this? A few plain sentences.
- Tell me the story from the start: what was going on, and what happened next, up to where it stands today. (Follow up: who else worked on it, and which parts were theirs? What went wrong, and what came of it? What is still open?)
- What did you personally own or build on it?
- Which decisions did you make — on the design, the plan or the approach — which alternatives did you reject, and why?
- What scale did it run at? (customers or users, volume, budget or revenue, data size, requests/sec, team size — real numbers)
- What measurably changed because of it? (cost saved, revenue won, hours saved, adoption, latency cut)
- Which tools or stack did you use — and what would you do differently today?
Then write the file from their answers only, organized like the skeleton above: nothing they didn't say, numbers only where given, the story in the order it happened — and as much grounded detail as the interview produced.
Either path ends the same way: a rich, grounded file — written
from what you knew (chats, repos, systems) or from what they told
you — nothing invented. The same mining + [ASK ME: …] discipline
applies to the Applicant Profile when you round it out: every skill at
real depth, every quantified win, everything that got cut for space.
Hand the finished files to your user to paste into the workspace (or
walk them through it in the editor).
Before your next search
Round out the Applicant Profile, add the first project file — then start your search. (Assistants: that's your cue to interview or write, above.) The difference is not subtle.
Working from your coding environment
The write-ups above are pure gold when they're written where the work happened. If you have an AI assistant in your coding environment — your IDE, your terminal — it has already seen your projects: the commits, the decisions, the corrections it gave you. That's the richest source a project write-up can have, and richer than anything you'd write from memory in a form.
So work where your context lives: ask your coding assistant to write the project file from what it knows (the instruction set at the end of this page works for any capable assistant), then bring it here. Markdown in, markdown out — paste it into a project file in the workspace editor, and it behaves exactly like a file you wrote yourself.
Bringing files over by hand is today's answer — we're actively building a way for your assistant to update Jobbee directly, no copy-paste. Until then: your environment writes, you paste, Jobbee tailors from the result.