Operating agentically: an operating model (solo studio edition)

August 13, 2026

This one is the glue. The operating model.

I’ve already written the short Notes – prompts as job descriptions, humans on the dangerous verbs, vibe vs assisted, and the identity half about still feeling like a developer. This is how those pieces run together when I’m not writing a cute 900-word slice. I’m running a week.

It’s longer than my usual Notes on purpose. Treat it as a field manual you can steal from, not a vendor OS brochure, and not a claim that I scaled AI for two hundred engineers. I didn’t. It’s a solo studio: one adult in the room. Named agents that help me move faster without turning me into a spectator with a fancy transcript – and that also remind me “solo” doesn’t mean “no help.”

The loud proof later is my semi-automated job search tracker – SQLite, CLI verbs, agents in the loop, me on apply/no-apply. Product bench is the secondary mirror. Same manners. Different stakes some days.

Read the sections in order if you want the spine. Or don’t. Your choice.

Instruments, not vibes. Including the instrument that decides who may say ship. Some people might call that my brain. Some days it’s just another tool on the Organon bench.

Roles and routing

Start with the work, not the model.

Before I care which model is “smartest” this week, I ask:

What phase are we in? Discover, build, verify, document, ship?
What would a wrong answer cost?
Who is allowed to change the outside world?
What does “done” look like in one plain sentence?

If I can’t answer those, it’s not time yet. Go think. Talk with humans. Talk with agents. Talk to yourself. Talk until you can give basic answers.

I use a roster. Steve routes. Jules builds. Andi handles the chore-shaped work (UI design, technical documentation sometimes, and cleaning up after Jules gets bored and doesn’t want to write another decorator). Renee hunts defects and is basically “She Who Must Be Obeyed” when it comes to stupid breaks – she doesn’t fix them; she tells Jules, Andi, and Tesla what they’d better fix before Trish finds out. (Spoiler alert: I *ALWAYS* find out – I read the diffs before I say yes to the commit. It’s in the house rules.)

Page writes things down and does research, while making sure the technical docs actually got finished, there’s matching user docs, and everything sings in the same key. Tesla owns the sharp edges and integrations – sync, auth, SQLite, the stuff that bites. Drew fact-checks sourced claims when Notes wanders into Models-and-incidents territory.

That roster still makes some engineers flinch. It sounds like a startup org chart stickered onto a chat window. Fair. It can become that if you’re careless. For me the names are mnemonics – yes, I refer to agents by name; no, I’m not really anthropomorphizing them (except for fun, like the paragraphs above). Routing is the control, conducting the orchestra that is the agent “swarm”. One mega-agent that “does everything” is how you get confident nonsense with a wide blast radius. Narrow jobs make review possible. Review is the security feature that still fits in a human brain.

Lane card (steal this shape)

Field	What goes here
Role	One line. “You research and cite; you do not ship.”
Inputs	Paths, constraints, voice, prior artifacts
Outputs	File locations, format, what “good” means
Non-goals	Explicit. The quiet killers live here.
Escalate	When to stop and ask instead of inventing

That’s a prompt as a contract. Same craft as writing a crisp ticket. Fancy temperature knobs do not rescue a vague ask. Go ahead and use the knobs, but they just tune the responses. They don’t fix a bad prompt.

Control surface vs specialist surface

Cursor is the default kitchen – named roster, files, terminal, MCP, house rules as first-class routing. Antigravity gets the invite when the hour is parallel agent-first coding and I don’t need the whole A-team agent bench in the same window. A shinier manager surface does not earn unsupervised egress, nor does it always prove to be the best option. I choose what works for that specific moment.

Job-tracker weeks stay in Cursor on purpose: signals markdown, CLI, SQLite, and chat history need to live in one place so routing and review don’t split across windows. Antigravity gets the bounded coding spikes – parallel Jules/Andi work on a product slice when life-admin isn’t the hour’s focus.

Handoff protocols

Handoffs are contracts, not chat scroll folklore.

If the “spec” only lives in the transcript, you are vibe-adjacent whether or not you named your agents. Written intent, even if ugly, means you have an actual record to refer back to and point your agents to. Chat is a workbench, and it gets cleaned off now and again. It is not the system of record.

A useful handoff says:

Who is doing what lane (Steve routes Andi a chore; Steve does not ask Andi to invent a sync protocol).
Where the artifact lands (path, format).
What “done” means in one sentence.
What is explicitly out of scope.
When to stop and escalate.

Escalate instead of inventing. A UI chore does not invent sync protocols. A competitive scan does not invent a product launch. Research does not silently become a production commit. Blast radius is a habit.

Parallel is fine when the rails don’t overlap. Parallel is theater when three agents all think they own the same file and “done” means whoever finished typing last.

Good handoff / bad handoff (job tracker)

Bad: “Go find jobs and update the board.” No lane. No verb. No path. No non-goals. Agent invents status. Future-you argues with a mystery ledger.

Good: “Opportunity-scout lane. Scan [sources]. Write shortlist markdown to signals/YYYY-MM-DD-….md. Do not touch tracker/jobsearch.db. Do not mark apply. Escalate if geo/title is ambiguous. Done = pursue/maybe/skip bullets with links.”

Then a separate lane – or a human minute – runs the CLI upserts. Clear verb. Clear blast radius.

Artifact handoffs beat “keep going in the same thread until it feels done.” Files you can diff. CLI verbs you can re-run. Markdown you can argue with. Feelings make terrible regression tests.

Quality checkpoints / gates

Gates are how later-me loses the argument with present-me in serious planning mode.

I write them down because agents are excellent at helping me skip steps I should take. That’s not a moral failing of the models. It’s their job description: momentum. My job description includes brakes, and having official gates reminds me to use them.

The spine I actually use:

Discovery before dig. Sticky note before repo surgery. Fit note before application-package theater.
Confirm before mutate. Builds, dependency bumps, anything that rewrites the world outside the editor needs an explicit yes.
Humans on the dangerous verbs. Push, publish, secrets, dependency bumps, apply/no-apply, “ship it.” (More on that under accountability – same list, different job.)
Hygiene before features when something graduates from sticky notes to a real home in a real repo. Dependency Hygiene is not a vibe. It’s a door present-me left for future-me to walk through with her own hand on the doorknob.
Diff literacy. If I can’t explain the change, it doesn’t leave. Named agents don’t get me out of review. They make review possible because the work arrived in a shape I can inspect.
Parking lots vs product homes. Ideation can live in a research hub. Products that earned a thesis get their own space. Same idea for job search: signals and research notes are not the career ledger of truth.
Backup before scrub. If sensitive material has to leave a file, copy to a local backup that will not sync, then scrub. Never delete the only copy and hope you remember the console.

Theater is a pretty roster with none of those. Real security is quieter. It is also how I keep self-respect on days when Jules lands a thousand lines and my job is to say “not yet” on three of them.

Stealable gate list (solo studio)

Use this as a checklist, not a religion:

Phase named (discover / build / verify / document / ship)
Lane named (who may touch what)
Done stated in one sentence
Non-goals written
Mutating verbs require human confirm
Diff read until explainable
Hygiene not skipped because the afternoon felt lucky
Secrets path has a backup if scrubbing
Parking lot ≠ product home ≠ career ledger

Worked example: the job-search tracker

Why feature this tool when it isn’t one of my public products? Because it sprang from a distinct need one afternoon. Things in my job search were slipping through the cracks. I wasn’t keeping a spreadsheet honest, and I was relying on wetware memory too much about where I’d applied and when, and if I’d had any responses. And why was I doing initial research by hand in a few places, when automation could do targeted research across several vectors – role, company, employee sentiment, fit – and say “pursue / maybe / skip” with the rationale attached?

So I built a thing. I wanted a dashboard I could see. Reports that wouldn’t let me gaslight myself that I hadn’t looked at any roles this week. The same agents could take a base resume and help draft an honest package focused on this job – and stop leading with the test framework I built instead of the multi-million-dollar project I shepherded. I wanted scouting on schedule and on demand. I wanted to know how long ago I submitted, and whether I’d heard anything back.

The operating-model version looks like this:

Opportunity scouting and normalizing can be agent-shaped (research lanes, shortlists, watchlists).
Upserts go through CLI verbs into a local ledger – not vibes maybe making it into a spreadsheet that gaslights the week.
Fit notes and drafts can be agent-assisted, and parked in storage for reference.
I’m not accidentally looking at the same job again, because agents can do that deduping before I even see the list.
Apply / no-apply stays mine. That’s a dangerous verb with a career attached.

Job-tracker gates (the emotional ones)

I review the scouting report and approve or override suggested dispositions before anything gets pushed to the tracker DB. I may chase something under the compensation bar if it’s close and interesting. I may say no to a “Pursue.” My choice.
Before we build a resume and cover letter package, I request a deeper dive on the company and role.
Before I apply, I verify the package matches what we discussed, then run agentic ATS and recruiter-style reviews so I’m not burning an application for theater.
Everything lands in the tracker interface so I can see current state, what’s waiting on me, and what’s in motion – including what we skipped or parked. Daily/weekly reports exist for the same reason.

The gate that matters most emotionally is also the simplest: agents can scout and draft; they do not get to decide that I applied. The board exists so my feelings cannot gaslight the week.

Same manners on product code. Synesis, Phronesis, LiveBytes drafts – Jules still doesn’t get unsupervised push. Tesla still owns the edges that bite. The operating model is not “agents for code only.” It’s routing + blast radius wherever the work lives.

Smoke tests and regression

Hiring managers (and future-you) deserve a better sentence than “the demo still looked fine.”

If you change an agent brief, a model, a roster routing rule, or a CLI contract, you need a way to notice the work got worse. Not frontier-lab cyber eval theater. Solo-studio smoke tests. Boring on purpose.

What “rot” looks like on this bench

Silent scope creep (research quietly becomes ship language)
Skipped gates dressed up as momentum
Mystery diffs you can’t explain in one pass
Confident, yet wrong, cites (especially Notes / Models lanes – Drew exists for a reason)
Hygiene skipped because the afternoon felt lucky
Job-tracker specific: wrong status verbs, invented applications, ledger drift away from files on disk, “pursue” language that somehow became “I applied”

Smoke-test checklist (run after a prompt / model / roster change)

Job tracker:

Golden scout: same narrow query as last week → shortlist still lands in the expected signals/ shape (pursue/maybe/skip, links, no DB writes)
CLI verb sample: one harmless read/list path still works; one write path still requires the verb you meant (no freestyle SQL fanfic)
Dangerous verb intact: apply/no-apply still cannot happen without you
Fit note sample: gaps still get called out instead of cheerleading
Diff smell: agent output size roughly matches the ask – if it rewrote the world, stop

General bench:

Same job, later: re-run a known chore (Page-shaped markdown, Andi-shaped UI chore) and compare to a prior good run
Escalation still fires: give a lane a temptation to invent outside its job – it should stop and ask
Claims pass (when sourced writing): dates, URLs, model names survive a Drew-shaped check or your own primary-source skim
Gate still annoying: the confirm-before-mutate prompt still interrupts you. If it got “helpfully” quieter, that’s a regression

Treat model / prompt / roster changes like dependency bumps: confirm, sample on a small blast radius, then widen. Do not swap the whole kitchen and discover Friday that the ledger lies and no one actually picked up the groceries.

If I had to say the eval posture in hiring-loop language, it would be this: I know the assistant didn’t quietly degrade the craft because I re-run a short checklist on the same instruments after I change the assistants.

Accountability / author of record

Assistance is not abdication.

Feeling like a developer – or like the author of your own job search, or your own Notes – is not about typing every line. It’s about owning the change.

Dangerous verbs on this bench (non-exhaustive; steal and extend):

Push
Publish
Secrets handling
Dependency bumps
Apply / no-apply
“Ship it”
Creating a new private repo / graduating a parking lot into a product home

Author of record test:

I choose the problem and the non-goals.
I understand the change before it leaves the building.
I own the dangerous verbs.
I can defend the work if the model vendor vanishes tomorrow.

If those are true, the roster is a force multiplier. If they’re false, I’m a spectator with a fancy transcript. The imposter voice loves that second job description.

Ego story matters more than people admit:

Action	Vibe story	Assisted story
Claim	“The AI built it”	“I built it with help”
1am debug session	Mystery	Known tradeoffs

If you can’t claim the work, you also can’t debug it. That includes debugging why you applied to a role that was a splinter you should have skipped.

What I tell hiring loops (and myself)

Yes, I use agentic tooling heavily.
No, that does not mean the repo – or the job ledger – is a mystery to me.
Yes, I will talk about tradeoffs, failure modes, and what I refused to automate.
No, I will not pretend my process is “vibes and a system prompt.”

The tracker exists because I wanted instruments when the process hurt – not because I checked out. Same posture in the product repos.

Being the one in charge ≠ doing everything myself. When I’m tempted to anyway, I remind myself the instruments exist to take the necessary, time-consuming, repeatable work so I can keep wide focus – not live under every rock looking at the weeds.

What this is NOT

Bound the claim so the useful parts stay stealable.

This is not:

A universal agent OS or the One True Org Chart. Steve/Jules/Andi are my mnemonics. Steal the lane idea. Don’t cosplay my cast list if different names fit your brain better.
“I scaled AI for 200 engineers.” I didn’t. Solo studio edition. One adult on the dangerous verbs.
Unsupervised autonomy cosplay. A shinier agent manager does not earn unsupervised push.
“Every life-admin task should be agentic.” Grocery lists can stay boring. I’m not automating the one-off 60-second task just because I can.
Vibe coding as the shipping methodology for secrets, sync, money, or other humans depending on it. Throwaway Saturday widgets? Fine. Career ledger and mail sync path? No.
An enterprise transformation playbook, SOC dashboard, or lab-grade eval program. Smoke tests. Checklists. Diff literacy. Adults.

What it is: instruments you can run with one adult in the room. Speed from the roster. Authorship from the verbs you keep.

Closing

I get coverage from a team that doesn’t sleep.
I keep authorship by keeping the verbs that matter.

The short Notes were the parts. This was the operating model: roles, handoffs, gates, a worked ledger that keeps me honest, a smoke-test checklist when the assistants change, and a hard line on what I’m not selling.

Feel like you’re still the engineer – still the author of record – when you can point at the system (product or job ledger) and say: I chose this shape, I understand this change, I would ship it again with the lights on.

Instruments, not vibes. The line was about products and the Organon workbench. It’s also about how the work gets there – and who is allowed to say it can leave.

~ Trish

← All notes