Tillness

For solo founders building complex products

The engineering org you don’t have.

Tillness turns your product requirements into verified, production-ready pull requests — a coordinated team of AI agents doing the rigor, while you make the calls that matter.

Only have an idea? Start in the Studio →

One install, one browser sign-in. No API keys in env vars.

Your inbox · Thursday, 8:04 am

est. 6 min

merge-readyStripe webhook idempotency9 gates ✓ · PR #48

merge-readyUsage-metering rollup job8 gates ✓ · PR #47

architectureRender invoice PDFs in a background jobveto or proceed

scope requestProtected path unlock — src/billing/**this item only

4 items in progress — no action needed

The slop wall

AI coding makes the first 20% feel magical. Then complexity wins.

/01

Agents contradict each other’s architectural decisions — nothing remembers them.

/02

Scope drift: every change quietly breaks two others.

/03

Code accumulates without tests, review, or traceability.

/04

“Done” means the agent said so — not that it was proven.

/05

Where requirements are silent, agents silently invent behavior.

/06

You become the integration layer between chaotic sessions — the one job one person can’t do.

Codebases that grow fast and die around week six. The bottleneck isn’t generation anymore — it’s trust, memory, and coordination.

The agentic org

An org, not a workflow. You’re the CEO/CTO.

Nine specialized roles with separated responsibility and authority — the way a strong engineering org separates them. You never manage the agents; they escalate only what needs a human.

¶Analyst

Parses the PRD, extracts requirements, finds the contradictions and gaps before they become code.

escalates: ambiguity · conflicts

☰Planner

Decomposes requirements into scoped work items with acceptance criteria and allowed paths.

escalates: scope tradeoffs

◆Architect

Makes and records ADRs; decision #3 constrains decision #47 — forever.

escalates: high-risk decisions

◇Designer

Turns your inspiration into binding design decisions and tokens; reviews UI diffs for drift.

escalates: taste calls — always yours

⌘Implementer

Executes work packets through your own coding agent, inside allowed paths it cannot leave.

escalates: blocked · scope needed

⌕Reviewer

Checks every diff against requirements, ADRs, and conventions — before and after submission.

escalates: never — findings return

▲Security analyst

Semantic security review on risk-flagged items only: authz flaws, injection paths, exposure.

escalates: risk acceptance

✓Verifier

Replays every claimed result in a clean, independent runner. Agents never grade their own homework.

escalates: never — gates decide

≡Documenter

Post-merge, off the critical path: docs, changelog, and API references stay in sync with the code.

escalates: never — docs can’t block

The daily loop

15–30 minutes a day. The rest is normal work.

Merge

PRs arrive with traceability, resolved findings, and a runner-verified gate report. You check judgment — not hunt bugs.

Decide

Architecture questions, ambiguity answers, scope unlocks — structured, ten-second-to-two-minute decisions that become permanent org memory.

Build

/tillness:next pulls the next scoped work packet straight into Claude Code — objective, requirements, binding ADRs, allowed paths.

~/ledgerly $ /tillness:status

Your org overnight:

▸ 2 PRs verified, merge-ready

▸ 1 architecture question awaiting decision

▸ 1 scope request (protected path: billing)

▸ 4 items in progress — no action needed

~/ledgerly $

The trust model

“Done” means proven — never “the agent said so.”

One architectural rule, applied everywhere: the client is fast, the server is true. Stripping every local guardrail changes nothing about what can merge.

Client — speedbest-effort

Hooks block out-of-scope writes the moment they’re attempted. Post-edit typecheck and lint kill cheap failures in seconds. Never evidence — results cap at locally observed.

Server — truthauthoritative

Independent runners replay every claimed result in a clean environment and re-check path compliance on the submitted diff. Evidence earns runner verified and above.

Every result is labeledself-reported→locally observed→runner verified→CI verified→human approved

Every merged line traces back.

The traceability map doubles as your investor demo — and later, your audit story.

PRD

§4.2 Billing

your document

Requirement

REQ-041

exactly-once webhooks

Work item

TIL-112

scoped · gated

Pull request

PR #48

traceability attached

Evidence

9 gates ✓

runner verified

Evidence over claims.

Progress derives from accepted artifacts and passed gates — agent activity is reported as cost, never as progress.

Rigor is the default.

You never configure gates, roles, or workflows. Opinionated defaults per stack — you see decisions, not process.

Escalate, don’t administrate.

Where requirements are silent, agents ask instead of inventing. Your one-sentence answer becomes a named requirement.

Ship something ambitious
without it collapsing.

Reach week six with dozens of merged, verified, traceable PRs — not a codebase you’re afraid of.

Start with an idea →

tillness— the control plane above your coding agent