A Mini-Org Inside the Company
I’ve spent the last stretch of my career at the awkward intersection where AI stopped being a demo and started being a coworker.
Most people are still optimizing prompts. That was interesting for about five minutes.
Once models can write, review, and restack real code, the scarce skill moves. It becomes how you run the work: priorities, disagreement, verification, and knowing when a project is actually over. Inside a large company, that looks less like “chatting with a bot” and more like standing up a tiny org chart that doesn’t collapse into chaos.
I’ve been doing that for real product work — not as a side hustle toy, as a way to ship. This is what I’ve learned.
The mistake: one mega-assistant
The default impulse is to build one chatbot that does everything.
That’s how you get a confident mess. One window becomes your calendar, your inbox, your coding desk, and your product owner. You feel busy. You don’t get leverage.
What works is more boring and more powerful: specialized seats with sharp refusals.
- A priority owner that decides what matters — and refuses to become ops + coding + strategy at once
- An ops seat for the daily loop when you want it
- Consult seats that stretch ambition or stress-test a plan before you believe it
- Specialists that hold research, specs, and memory that doesn’t die in Slack
- Coding agents as contractors: they ship changes; they don’t decide what the product is
The rule I won’t bend: don’t invent a standing role because it was convenient once. Temporary helpers for a project are fine. Permanent seats should earn their keep — and someone should have to argue for them on purpose.
If the roles blur, you didn’t build a team. You built branding.
Proof isn’t “AI wrote code.” Proof is a project that ended.
I care about this because I’ve watched teams confuse generation with progress.
A useful proof point from my own work: we had an important policy living as three copy-pasted paths in a host app — same rules, three doors, three futures. The bet was intentionally narrow. Put the policy in one shared place. Rewire the doors. Freeze the wrong layer so the next change doesn’t land there again.
How we ran it matters as much as what we shipped:
- Stacked pull requests, bottom to top
- Tests and automated review as early as the environment allowed — not “CI will catch it”
- Automated review before humans while it was still catching real issues
- Temporary CI watchers for that stack only — deleted when the stack landed
- Docs for the next agent so the policy kept landing in the shared place
What we got: one place for the policy, faster package-level validation, a clearer seam for the next cut.
What we did not get: the whole product area extracted. That was never the bet. The project was the door, not the house.
I’m proud of the honesty in that scope. Shipping a seam and stopping is a leadership skill. Endless “almost extracted” work is not.
What this is actually good for
If you only use a setup like this to open PRs, you wasted it.
The leverage I’ve seen:
- Parallel work with one priority owner — research, specs, stress-tests, and coding at once instead of serializing yourself
- Memory that outlives Slack — domain context that compounds
- A finish line you can reuse — tests and review early, every project
- Decision packets for humans — what / options / recommendation / risks / ask — before the meeting sprawls
- Projects that end — temporary roles and watchers die with the bet
This is how you advertise capacity without pretending green CI is a strategy.
The traps (because the hype won’t mention them)
Coding desk with extra labels. You stand up priority, ops, ambition, stress-tests, research — then every week is still open PR / fix CI / restack. The org chart looks sophisticated. Practice is still a software desk.
Review landfill. Automated review is force-multiplying until the timeline is noise. Keep the short “what we fixed” notes. Delete the chatter. Close finished threads.
Default max spend. If agents inherit the most expensive model by accident, you’re paying executive prices for intern work. Real teams manage headcount. This kind of setup has to manage model spend the same way.
Why I’m writing this
I’m not selling a prompt pack.
I’m making a bet about where senior technical leadership is going: the people who can organize AI-assisted work inside a real company — with clear roles, honest scope, and endings — will outrun the people who only generate diffs.
Green still isn’t trust. A stack of green PRs still isn’t product judgment.
But a small, disciplined system that can land a real seam and then stop? That’s capacity. That’s the thing I’m building in public.
The part that stays human is the only part that ever mattered: deciding what the team is for.