# 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](https://github.com/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):

1. Which project is this? A few plain sentences.
2. 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?)
3. What did you personally own or build on it?
4. Which decisions did you make — on the design, the plan or the
   approach — which alternatives did you reject, and why?
5. What scale did it run at? (customers or users, volume, budget or
   revenue, data size, requests/sec, team size — real numbers)
6. What measurably changed because of it? (cost saved, revenue won,
   hours saved, adoption, latency cut)
7. 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.
