Less People.
More Output.
How Ottu rewired its operating model around AI agents — and what it unlocks for delivery, predictability, and capital efficiency.
The companies that win the next decade will deliver more with fewer people — because their internal coordination cost approaches zero. Ottu is building exactly that. This deck is what it looks like, how it's progressing, and why it compounds.
The coordination tax.
- Kickoff meetings to explain scope to the people who'll build it.
- Standups that exist to surface what tickets should already say.
- Ad-hoc clarifications — Mattermost pings, WhatsApp calls, hallway questions, "got a minute?"
- QA ↔ Dev handoff meetings to explain what was built and what's broken.
- Scope debates that re-litigate decisions made weeks earlier.
- Missed memos — one person was in the call, another wasn't, info doesn't propagate.
Lean calls this muda — waiting waste. We're calling it the coordination tax, because it's a line item leadership can actually see and reduce.
Today, most roles spend half their day not delivering.
Illustrative split based on team estimates. The exact numbers vary by team and quarter — the shape doesn't.
Tuesday morning, across three roles.
- 09:00Kickoff meeting for new feature — 5 people, 1h
- 10:00Mattermost ping: dev asking about Monday's ticket
- 10:30Call to clarify scope
- 11:30QA chases scope — re-explain
- 14:00Coach a new dev on context
- 15:00Marketing brief for last week's feature
- 16:3030 min of actual writing
- 09:00Daily standup — 30 min, 15 people
- 09:30Open ticket — ambiguous, ping PM
- 10:00Wait for reply, look at unrelated code
- 10:30Call with PM — scope clarified
- 11:3090 min of real coding
- 13:30Bug call with QA — 45 min
- 16:0060 min of real coding
- 09:00Standup — different one
- 09:30Chase devs to demo Friday's work
- 11:00Write test plan in Confluence — guess at scope
- 13:00Manual testing
- 14:30File 3 bugs, ping devs on WhatsApp
- 15:30Bug call with dev
- 16:30Update test plan with what was learned in call
Most of the day is spent ferrying knowledge between people. The highlighted entries are the only ones that produce output.
People used to be the knowledge bus. Now a service is.
People are the bus.
Every person is responsible for routing knowledge to every other person.
The Knowledge Service is the bus.
Each role queries one shared source through their own AI agent.
Knowledge stops being a liability. It starts being an asset.
A depreciating intangible
- Lives in people's heads
- Context fades within weeks of shipping
- Walks out the door when someone leaves
- No replay — onboarding restarts from zero
- Never measured, never on the balance sheet
Appreciating organizational capital
- Lives in the Knowledge Service
- Compounds — every ticket adds to the corpus
- Doesn't churn — survives turnover
- Always queryable — onboarding becomes "use these agents"
- A measurable asset that shows up in margin per engineer
We stop running on a depreciating intangible and start compounding an appreciating one. That is the structural shift.
Four components. One always-current map of Ottu's reality.
Code knowledge
What every service does, what calls what, and what breaks if you change it. Drawn from the codebase itself.
Ownership & deployment
Who owns every service, who backs them up, where each one is deployed, how it ships. The org chart for software.
Infrastructure-as-code
Every queue, droplet, DNS record, secret, scaling policy — discoverable as data, not tribal memory.
Public product docs
docs.ottu.com — already live as an MCP. The outward-facing truth, queryable alongside the inward one.
Together: three internal components + one external — the substrate every AI agent at Ottu queries before doing anything.
One Knowledge Service. An AI agent for every role.
Ticket-planner skill
Turns intent into a fully-reasoned ticket with impact, estimates, and child tickets.
Claude Code + code-graph
Implements with full callers/callees visibility. Answers "what breaks if I change X?"
Claude Code + Playwright
Generates end-to-end tests as code. Shared with devs to run before claiming "fixed."
Claude Code + IaC knowledge
Sees infra impact before it lands. Plans capacity instead of firefighting.
Skill-specific agents
Generate newsletter, positioning, and talk-track from the same ticket.
Investor-brief skill
Roadmap evidence and board narratives — same source, board-grade output.
One conversation. A fully-reasoned ticket.
- Services impacted: customer frontend · Checkout SDK · WebSocket service · Core backend · infra
- Impact pre-computed: security, code, infrastructure, compliance scope
- Real estimates — grounded in the actual codebase, not a ballpark
- Child tickets auto-spawned — design ticket, infra ticket, compliance evidence ticket
- The ticket becomes the single source of truth — for everyone, forever
No technical hand-waving from the PM. No subsequent meetings to explain it. The ticket arrives complete.
One ticket. Every audience gets the slice they need.
source of truth"]:::core pm["PM
scope · estimate · ownership"]:::role dev["Developer
impact map · code locations"]:::role qa["QA
test scope · acceptance"]:::role ops["DevOps
infra changes · runway"]:::role comp["Compliance
scope · evidence tasks"]:::role sales["Sales
customer-facing summary"]:::role mkt["Marketing
feature narrative"]:::role ir["Investor Relations
roadmap evidence"]:::role ticket --> pm ticket --> dev ticket --> qa ticket --> ops ticket --> comp ticket --> sales ticket --> mkt ticket --> ir classDef core fill:#e07a3c,stroke:#e07a3c,color:#0f1115 classDef role fill:#1a1f2b,stroke:#3a4254,color:#e6e8ee
No one has to attend a meeting to learn what's coming. The ticket already told them.
The PM's day, before and after.
Most of the day is explaining.
- Long stretches of meetings to explain, re-explain, coach
- Tickets are stubs that grow during the project
- Constant context-switching for clarifications
- Marketing & sales arrive for briefings — re-tell every time
- Real writing happens in the gaps
Most of the day is crafting.
- One planner session per epic produces a complete ticket
- Updates broadcast through ticket comments — not 1:1
- No coaching loop — devs have their own agent
- No briefings — marketing & sales generate from the ticket
- Most of the day is crafting the next thing
~ 4× more output time. Not by working longer — by stopping the wrong work.
The developer's day, before and after.
3–4 hours of real flow on a good day.
- 30 min daily standup — context-switching tax
- Tickets ambiguous on arrival — DMs and calls to clarify
- Cross-service work means hunting for callers/callees manually
- Bug ping-pong with QA — re-explain in calls
- Flow time fragmented into 90-min windows
6–7 hours of real flow, sustained.
- No standup. Status lives in the ticket.
- Tickets arrive with impact map and code locations
- Agent answers "what calls this?" and "what breaks if I change Y?"
- Tests-as-code shared — devs run them before saying "fixed"
- Coordination cost approaches zero
Output rises 30–50% — not because anyone works harder. The context-switching cost collapses.
No more infra requests out of nowhere.
Infra requests land mid-sprint. "We need a new queue." "Bump that droplet." "Add this DNS record by tomorrow."
DevOps is interrupt-driven. The roadmap is whatever broke yesterday.
Capacity is consumed by surprise.
Every ticket pre-declares its infrastructure impact — because infrastructure-as-code sits inside the Knowledge Service.
DevOps sees the full runway weeks ahead. New queues, scaling, DNS, secrets — all visible before a single line of feature code is written.
Planned capacity replaces firefighting.
Audit prep stops being a project.
Compliance evidence is chased after features ship. PCI scope is inferred ticket-by-ticket. ISO controls get documented retroactively.
Every audit cycle is a multi-week scramble involving every team.
Compliance is an afterthought.
Every ticket auto-detects PCI / ISO scope from the services it touches. Evidence sub-tickets are auto-spawned at planning time.
The audit trail is built as a side-effect of normal work. Auditors get a ready-made trail, not a fire drill.
Compliance becomes a byproduct.
Half the meetings simply stop existing.
- Kickoff meeting — PM explains scope to devs
- Daily standups — status surfaced verbally
- Clarification chats — Mattermost, WhatsApp, hallway
- QA handoff meeting — what was built, what to test
- Bug ping-pong calls — "is it fixed?", "no it isn't"
- UAT walkthrough — PM walked through manually by team
- PM crafts the ticket with the planner
- Devs ask their AI agent for any clarification
- QA generates tests-as-code from the ticket directly
- Devs run the same tests before declaring it done
- PM validates by reading the tests — no walkthrough
- Updates flow through ticket comments — everyone notified
Less time in calendars. More time in flow. Information stops getting lost between people.
The gap the Academy was built to close.
Sales & marketing learn second.
- New features ship — sales finds out from Mattermost, marketing from a release note
- Positioning, talk track, objection handling: built ad-hoc, weeks after launch
- Pricing implications discovered in the first customer call
- The Academy bridges this — scheduled deep-dive sessions for major releases
- But the Academy is batched. The day-to-day, ship-by-ship knowledge still leaks.
The Academy isn't replaced. It's amplified.
- Every ticket auto-produces a sales-ready brief in real time
- Newsletter, feature page, positioning, talk track — generated alongside the feature
- Sales rep asks their own agent: "what new payment integrations shipped this month?" — answered from the same Knowledge Service
- Academy keeps its place: deep dives, vision, big releases
- Day-to-day knowledge flows continuously through agents, underneath
The Academy stays as the deep-dive layer. The continuous flow underneath means no rep is ever more than a question away from current truth.
The same ticket produces everything sales and marketing need — in tone, ready for review.
Customer talk track
What to say, who it's for, when to bring it up.
Objection handling
The pushbacks reps actually hear, with grounded replies.
Pricing & positioning
How this changes the deal — what to ask for, where to hold.
Case-study skeleton
Outline with placeholders, ready when the first design partner says yes.
Newsletter draft
Release-note email, in tone, ready for review.
Feature page copy
Web / app copy — headline through CTA.
Social post drafts
LinkedIn and X variations, ready to post.
Demo video script
30 / 60 / 90-second walkthrough variants.
The Academy keeps the deep-dive role: vision, strategy, major releases. This layer handles the continuous — the daily feature ship, the weekly competitor question, the one-off rep request — without anyone scheduling a session.
Every well-crafted ticket pays out across the business.
engineering reference"]:::out pubd["Public docs
docs.ottu.com"]:::out mkt["Marketing
newsletter · feature page"]:::out sales["Sales enablement
positioning · talk track"]:::out ir["Investor brief
roadmap evidence"]:::out comp["Compliance evidence
audit-ready artifact"]:::out t --> intd t --> pubd t --> mkt t --> sales t --> ir t --> comp classDef core fill:#e07a3c,stroke:#e07a3c,color:#0f1115 classDef out fill:#1a1f2b,stroke:#3a4254,color:#e6e8ee
Each output is generated by a dedicated skill from the same source. The ticket isn't a task — it's an asset that ships value to six audiences at once.
Every cycle leaves the knowledge layer richer than the last.
- 1Better ticket. Planner produces complete impact, estimate, and child tickets from one PM session.
- 2Cleaner work. Devs, QA, DevOps execute without coordination friction — each from their own agent.
- 3Richer outputs. Docs, marketing, sales, compliance evidence — all generated from the same ticket.
- 4More artifacts. Every deliverable feeds back into the Knowledge Service as queryable context.
- 5Richer service. The next ticket starts with more context than the last one. Marginal cost drops over time.
This is the moat mechanism — not the AI itself, but the compounding of organizational knowledge and the dropping marginal cost of every well-crafted ticket.
Skills as multipliers. When a new audience appears, we add a skill — not a headcount.
Documentation skill
Generates internal & public docs from the ticket — keeps them in sync with reality.
Newsletter skill
Features → release-note + "what's new" emails, in brand tone, ready for review.
Feature page & web copy skill
Features → headline, body, CTA — drop-in ready for the marketing site.
Sales talk track skill
Features → conversational scripts: what to lead with, when to bring it up, who it lands for.
Objection handling skill
Features → the three pushbacks reps will actually hear, with grounded answers.
Pricing & positioning skill
Features → how this changes the deal, what to ask for, where to hold the line.
Academy curriculum sync skill
Watches the live ticket stream; proposes which features deserve an Academy session, with a draft outline.
Investor-brief skill
Features → board-grade roadmap evidence and update narratives.
Evidence skill
Features → audit-ready artifacts mapped to PCI / ISO controls.
Onboarding skill
New hire profile → tailored ramp plan with the right docs, agents, and starter tickets.
Whatever comes next
A new audience appears, we ship a new skill. Every skill stacks on the same Knowledge Service. The org gets more leverage without getting larger.
Each skill is a leverage point — the same ticket turning into another audience's deliverable, at zero marginal cost per audience.
What this means in numbers.
Strategic position, not just operational.
Faster product cycles. Tickets are complete on day one — implementation starts immediately, not after a week of meetings.
Estimates that hold. Grounded in the real codebase, with impact pre-computed — surprises shrink toward zero.
Audit-ready by default. PCI DSS and ISO 27001 evidence accumulates as a side-effect of shipping.
Smaller fixed cost base. Higher margin per engineer, reinvestable into product — not consumed by coordination.
A lean org by design. Fewer people, faster decisions, less institutional weight. Easier to pivot.
The moat compounds quarter over quarter. Every ticket, doc, and test makes the next one cheaper to produce.
Ottu's competitive position stops being about how many engineers and starts being about how cleanly the org turns ideas into shipped product.
We're not at the start. We're past the proof.
The next 6–9 months are operationalization across the org — not invention.
Already shipping — and proven on a real service.
Shipped & in daily use
- Claude Code in use by developers and tech leads across the org
- Ticket-planner v1 for PMs — structured ticket pattern without the knowledge layer behind it yet
- QA adoption underway — Claude Code + Playwright for end-to-end test generation and automation
- Public docs MCP —
docs.ottu.comalready wired into agents
In flight
- ottu-knowledge — the central knowledge layer (code, ownership, infra, compliance)
- Knowledge-aware ticket-planner — full impact analysis across services, security, infra, compliance
- Code-graph deployment — callers, callees, blast-radius queries available to every agent
- Auto-spawned child tickets — design, infra, compliance evidence
Planned next
- Compliance evidence auto-generation as a byproduct of every ticket
- Marketing & sales enablement skills — ticket → newsletter, talk track, positioning
- Investor-brief skill — ticket → board-grade roadmap evidence
- Full autopilot rollout — the delivery cycle as the new normal across all teams
Wallet — end-to-end, by one person.
Dacian ran the full disruption cycle on the Wallet service himself — wearing every hat in sequence.
Less than 2 days wearing the PM hat. Less than 4 hours wearing the QA hat as support for others.
The concept isn't theoretical. It's been done. On a production Ottu service. By one person.
Less people. More output.
And the gap widens every quarter we run this way.
Ottu's operating model is being rewired so the next dollar of growth costs us less to deliver than the last one. That is what disruption looks like — measured not in headlines, but in margin per engineer.