Stop Prompting. Start Hiring.

First, the data

I am not guessing here. I audited my own laptop. My setup (Claude Code — an agent that lives in the terminal, with access to my files, shell, and projects) records every session into a local memory database. So the last five months are fully measurable:

• 13,057 prompts between March 4 and July 21 — I used it on 137 of 140 days, in May all 31 days
• Around 93 prompts per day, and the average prompt is only 283 characters
• 28,747 recorded observations across 15+ projects
• And the outcome, from mining 13 years of git history separately: my 2026 commit output is running more than 50% above my best year ever — the same year I made this shift

One more number that matters: the word "deploy" appears in 649 of my prompts, "test" in 593, "fix" in 512. The boring verbs win. This is not demo enthusiasm — the agent does the unglamorous middle of real software work: day job, freelance clients, side projects, and the paperwork around all of it.

I climbed the same ladder as everyone: Copilot autocomplete early on, then Cursor as my editor, then the agent. Here is something I only noticed during the audit: the autocomplete and editor years left almost no trace on my disk. The suggestions dissolved into my commits, the chats are gone. The hiring model is the first one that writes itself down. I don't think this is a coincidence. Staff leave records. Vending machines do not.

Everything on my laptop that makes this work maps to something you would do for a human hire. In the order I would do it again:

1. The contract comes before the work

The most important file in my whole setup is only 64 lines: a global rulebook that applies to every session, everywhere. Some lines from it, paraphrased:

• Never watch or poll a deploy — start it, report it started, stop. I watch my own deploys.
• Never commit unless I explicitly ask. Lowercase, one-line commit messages.
• Always run date before reasoning about dates — sessions cross midnight, and guessing goes wrong.
• Before touching anything money-related, load my actual financial state first. No generic advice.

People ask me how I can trust an AI with production access. I think the question is backwards. You do not trust it in general — you constrain it in specific. Every line in that file exists because something annoyed me or scared me before. Ten lines of "never do X" buys more real productivity than any prompt library, because what it really buys is confidence to delegate.

2. Onboarding docs, not vibes

Each of my 21 active projects has a one-page briefing file in its root. Not documentation for humans — operating instructions for the agent: which test framework, what the linter accepts, how deploys happen, which parts are dangerous. One project's file contains the sentence "push to main triggers the deploy — never deploy manually", and this single line prevented the same incident more times than I can count.

Here is my opinion part: most AI coding failures are not intelligence failures. They are onboarding failures. When a developer shows me AI-generated garbage, I ask the same question you would ask about a failing junior: did anyone tell it the house rules? Usually the answer is no. The model was dropped into a codebase cold, and then blamed for not knowing things that nobody wrote down.

3. Job descriptions instead of prompts

This is the real unlock. When I catch myself explaining the same task a second time, I stop and write a skill — a markdown file that describes the job the same way you would brief a new hire: when to act, what steps to follow, what it must never do. I have 49 of them now. A few examples, so you can see this is not only about code:

• A deployment expert that knows my whole deploy setup, can tail production logs and open a server console — with a hard list of commands it must never run without asking me.
• A production debugger that takes a plain-English bug report ("operator says the totals look wrong"), reads the codebase, and writes a read-only diagnostic script to run safely against production data.
• A monthly report generator that produces my formal monthly report in Khmer, following an official template, with all four required sections. What used to take an evening of formatting now takes minutes plus a review pass.
• A proposal manager that versions client proposals, renders PDFs, and keeps a changelog. Freelance admin — invoices, proposals, chasing payments — appears in around 280 of my prompts. Nobody counts this as "work", but it eats real evenings.
• A personal finance advisor that knows my actual numbers and is explicitly instructed to be brutal with me. I wrote "do not sugarcoat" into its job description, because I know myself — I would rationalize otherwise. It is genuinely unpleasant to talk to. It works.

A skill is 100–300 lines and costs less to write than doing the task twice by hand. After that, the task costs almost nothing, forever. This is why I say hiring and not prompting: a prompt is spent when the session ends. A job description compounds.

4. Institutional memory

Every session gets distilled into a searchable database — decisions, root causes, "we tried X and it did not work". The effect is quiet but real: I stopped re-explaining. A session can start with "continue the invoice thing" and the context is just there — which client, what we decided last week, what is still pending. The first time the agent reminded me about a follow-up I forgot, the relationship turned around a little. That was the moment it stopped feeling like a tool.

And one number I find genuinely strange: from 4,038 session transcripts on my laptop, 2,763 belong to the memory system observing the other sessions. Most of the AI activity on my machine is AI writing down what AI did, so future AI remembers it. Nobody designed this ratio. It grew — the same way institutional memory grows in a company.

"But it makes mistakes"

So do juniors. You do not conclude from one bad PR that hiring is a scam — you fix the onboarding. Every failure I hit became a rule or a better job description, not a reason to quit:

• Full autonomy on deploys — I tried it, I dropped it. Letting it watch a deploy end-to-end was slower than me glancing at a dashboard, and honestly I did not want to give that up. Now it is contract line number one.
• Mega prompts — before skills, I kept a folder of long, clever prompts. They aged badly and nobody maintained them. Skills won because they live next to the work and get edited like code.
• Browser-testing everything — sounds great, was slow in practice, and I trust code-level verification plus my own eyes more. Now it is opt-in only, by rule.
• Date reasoning — it would confidently reason from a stale date after midnight. One rule ("run date first") deleted this whole class of bug.

Notice the shape: not one of these failures said "the AI is not good enough". All of them said "the employment terms were not specific enough". That difference is the whole argument.

Where this lands

Five months in, my honest summary: AI did not replace my work. It replaced my overhead. Deploys, reports in a second language, invoices, boilerplate diagnostics, re-explaining context — that layer is mostly gone now, and the 50% jump in my git output is what was sitting underneath it. My days changed shape too: 9–11 in the morning is now my heaviest prompting window — I brief and delegate early, then review and commit late. The agent did not only speed up my work. It reorganized when each kind of work happens.

If you want to try the hiring model, this is the order that worked for me:

1. Write the contract first — ten lines of "never do X".
2. Give every repo a one-page briefing file.
3. Turn the third repetition into a job description. If you explained it twice, the third time is a file.
4. Add memory last. It compounds the other three — once there is something worth remembering.

I used to think I was getting better at prompting. The audit says otherwise: my average prompt is 283 characters, and many of them are just "ok move on". I did not become a better prompter. I became a manager of a very small, very strange company — 49 employees, all made of markdown.

Some details are generalized so clients, employers, and codebases cannot be identified.