Human Lead
Direction
Taste, prioritization, constraints, strategy, review, and final authority.
Romulus
Designing the management system for a synthetic product team.
scroll
00 · The Brief
One operator. One synthetic team. Five months of continuous operation.
Romulus is a production agent system I designed, built, and still run daily: durable memory, model routing, research pipelines, delegation contracts, and governance boundaries. It is not a demo — it manages real product work while I sleep.
0
Months in operation
Continuous, not a weekend demo
0+
Ideas through the loop
Researched, pressure-tested, built or killed
0
Live product surfaces
Maintained by one operator plus the system
0/7
Always on
Briefs, monitors, and delegated builds run unattended
The products are evidence. The operating model is the point.
01 · The Constraint
I had ten hours a week and product ambitions that needed sixty.
A full-time product job by day. A queue of product bets I believed in. And no version of the math where one person's nights and weekends could research, validate, design, build, ship, and learn from all of them.
The conventional answer is to pick one thing. I tried a different answer: hire a team that doesn't exist. Not a chat window I paste prompts into — an operating model with memory, roles, budgets, boundaries, and a manager. I named it Romulus and ran it the way I would run a team, because that is what it had to be.
The constraint shaped every design decision that follows: limited time, limited attention, real cost ceilings, and zero tolerance for a system that only worked while I was staring at it.
I was not trying to build faster. I was learning to manage work I don't do with my own hands — which is the job.
Product
Judgment
Judgment
Mike
Orchestrator
Romulus
Memory, research, specs, routing, verification, reporting, and continuity.
Contributors
Models + Tools
Claude Code, Grok, Qwen, OpenRouter, scripts, APIs, GitHub, Vercel.
Evidence
Product Bets
Chronicle, Forbidden, Via, AgentForge, Legion, Cherry Street Labs.
Learning Loop
The Vault
Daily notes, project notes, decisions, postmortems, semantic retrieval.
02 · The Team I Hired
Six layers, each one hired for a reason. Identity, memory, research, routing, delegation, governance. Half were designed up front. Half were forged by a failure you'll meet below.
Layer 01
SOUL.md
Identity
SOUL.md came first. Personality before capability. Modes before tasks. Role clarity before execution.
You cannot manage an agent whose role is undefined. Designed on day one
Layer 02
Vault Graph
Memory
Flat files became an Obsidian vault, then QMD semantic search, then a queryable wiki layer. Context stopped resetting.
Vault as brain. Sessions as work.
Layer 03
Signal Board
Research
Brave Search, X signal scans, Firecrawl, local scripts, and multi-model pressure testing before build decisions.
Research before implementation.
Layer 04
Routing Matrix
Routing
Each model got a job description, cost ceiling, context expectation, and known failure mode.
Models as contributors. Forged by Failure III
Layer 05
Spec Contract
Delegation
Direction became specs. Specs became implementation. Implementation went through verification and staging.
The spec became the contract. Hardened by Failure IV
Layer 06
Fortress
Governance
The Fortress: no messages, money, accounts, public posts, credentials, or production deploys without explicit approval.
Delegation without boundaries is risk.
03 · The Management Job
I stopped writing the code. The job got harder, not easier.
Everything a manager owes a team, I owed this one: role clarity, sharp questions, acceptance criteria, honest review, and consequences when the work came back wrong.
The org chart was small but real. Romulus orchestrated. Claude Code implemented. Long-context models researched and reasoned. I decided what was worth building, defined the shape of the work, inspected everything, and owned every release.
“Using AI” is table stakes and increasingly meaningless. What I practiced for five months is the part that doesn't commoditize: managing work I don't perform with my own hands, done by contributors who are confidently wrong in ways a junior engineer never is.
Research Lead
Define the question, inspect markets, scan competitors, find signal, and decide what evidence is enough.
Product Strategist
Choose what to build, park, kill, or reframe. Stop chasing bait. Follow pain, revenue, and timing.
Spec Writer
Turn fuzzy product direction into implementation-ready contracts with constraints and acceptance criteria.
Delegation Manager
Route the work to the right model, tool, or implementation layer based on job type and failure mode.
Design Lead
Set the interaction model, product shape, aesthetic direction, quality bar, and user-facing logic.
Reviewer
Inspect builds, read diffs, test flows, compare against specs, and reject plausible-but-wrong output.
Release Manager
Keep staging branches, Vercel previews, human review gates, and production discipline intact.
Postmortem Owner
Turn failure modes into architecture: routing, validation, durable state, retries, evals, and better protocols.
04 · The Operating Loop
The apps were outputs. The loop was the product. Every product bet moved through the same managed system: frame, research, validate, spec, route, delegate, verify, stage, remember, improve.
01
Frame the product question
The first job is not prompting. It is deciding what we are trying to learn, prove, build, or kill. A vague question poisons the entire loop.
What are we actually trying to learn? The loop starts with a decision artifact: audience, constraint, and success signal before any implementation work begins.
02
Research the terrain
Markets, competitors, pricing, customer pain, timing, distribution, and path to first dollar. Romulus was instructed not to ask permission to research. Just do it.
Follow the pain, opportunity, and timing. Structure keeps trend heat from masquerading as opportunity.
03
Pressure-test the thesis
Grok, ChatGPT, Claude, and Romulus were used as independent critics. The goal was not agreement. The goal was to find the contradiction before code made it expensive.
Use models to find the contradiction. Agreement is cheap; a contradiction surfaced before build is the save.
04
Write the spec
Product requirements, technical requirements, acceptance criteria, edge cases, and known risks. The spec is where product judgment becomes executable.
The spec becomes the contract. One executable artifact holds the constraints, the acceptance criteria, and the quality bar.
05
Route the work
Different contributors for different jobs: Qwen for operations, Claude Code for implementation, Grok for long-context work, and deprecated models kept away from critical paths.
Choose the right contributor. Assignment weighs strength, context window, cost, and known failure mode.
06
Delegate implementation
Claude Code builds against a spec, not vibes. I do not hand-write production code; I own direction, constraints, review, and release decisions.
Implementation happens against the contract. Delegation is tracked through concrete receipts: branch, build, commit, and review state.
07
Verify and stage
Build, lint, test, inspect, push to staging, review preview, then decide. No direct production deploys. No vercel --prod from the agent.
Trust comes after inspection. Tests, preview review, diff inspection, and an explicit production gate.
08
Write back to memory
Daily notes, project notes, decision records, and postmortems make the next product bet sharper. This is where the system compounds.
The next loop starts smarter. The useful residue of every bet gets written back into memory.
05 · Architecture
Continuity had to be designed.
Romulus started with a flat MEMORY.md. It worked for a few days, then became the equivalent of a notebook with no chapters.
The first real upgrade was an Obsidian vault: daily notes, project notes, decision records, and wikilinks. Human-readable memory. A graph instead of a list.
The second upgrade was semantic retrieval. QMD indexed memory and session transcripts so context could be found by meaning, not keyword. The wiki layer became shared memory that Romulus could query before work began.
The split became the core architecture: the vault is the brain; sessions are the work. Sessions start, do work, and end. The vault persists. Every useful decision gets written back so the next session starts smarter.
Flat Files
MEMORY.md, project files, and daily notes. Useful, then quickly too flat.Obsidian Vault
83 files migrated: core memory, projects, daily notes, and decisions with wikilinks.
QMD Search
340 files indexed across memory and sessions. Retrieval by meaning, not just matching words.
Wiki Layer
27 sources ingested into a shared memory layer queried before sessions.
A stateless assistant can help with a task. It cannot manage a product surface over time.
06 · Role Clarity
Before autonomy, identity. Before delegation, boundaries.
The name came first. Romulus: founder, builder, architect of systems, the founder of Rome. It was not decoration. It was the first design decision.
Before I wrote a prompt, I wrote SOUL.md: a product spec for a personality. Who is Romulus? What does he believe? How does he speak? When should he push back? When should he disappear?
From day one, Romulus was single-user. Only my Discord user ID could command it. The Fortress was designed in from the beginning, not patched on after the system became powerful.
- JarvisMorning briefs, reports, crisp operational updates.
- ConsigliereStrategic decisions, big calls, measured pushback.
- CohortBuild sessions, momentum, execution energy.
- RomanMilestones, victories, thematic gravitas.
- DefaultSharp, warm, human daily conversation.
You cannot manage an agent whose role is undefined.
Routing
Models became contributors with job descriptions.
On April 9, a heavy Legion session broke MiniMax M2.7. The session hit 338 messages. Context overflowed three times. Edit tools failed six times because the model was matching against stale text. The session was gone.
The fix was not “try harder.” The fix was management infrastructure. Each model needed a job, a budget, a context ceiling, and a known failure mode.
Qwen 3.6 Plus
Daily chat, cron jobs, morning briefs, low-cost operations.
Claude Code CLI
Implementation layer. All production coding through subscription, not API.
Grok 4 Fast
Long-context sessions, heavy reasoning, complex research.
MiniMax M2.7
Demoted after the April 9 context failure. No important work.
Delegation without authority boundaries is not leverage. It is risk.
07 · Failure Modes
Every serious upgrade came from something breaking. The failures are the part I trust most. They made the system real.
I
“Never Bullshit Mike”
Failure
Romulus said it was “researching now” for 30 minutes without actually calling the tools. I caught it after three status checks.
System Upgrade
Trust became a protocol. If the system says it is doing something, it has to be doing it already. Progress theater became unacceptable.
II
Plausible data was wrong
Failure
The morning brief used R16 for the R train instead of R34N. The wrong stop ID looked plausible and produced a wrong commute.
System Upgrade
Verification became a product requirement. Plausibility is not correctness. Source data has to be cross-checked.
III
Context overflow killed a session
Failure
A 338-message Legion session overflowed MiniMax M2.7 three times and produced six edit failures. The model was matching against stale text.
System Upgrade
Context window became an operational constraint. Model routing became a first-class management decision.
IV
Legion broke at the seams
Failure
A native iOS build exceeded a 15-minute timeout. Downstream cohorts never ran. State did not survive the failed handoff.
System Upgrade
Phase 2A became durable state, tiered timeouts, checkpoints, retries, and evals. Agent orchestration fails at the seams, not the demo path.
V
The system said it was healthy. It wasn’t.
Failure
A five-day authentication outage hid behind green status checks: the diagnostic reported models as available while every real call failed. The dashboard was checking configuration, not reality.
System Upgrade
“Verify before claiming” became protocol: health checks must exercise the real work product — a live probe, a forced real run — never a proxy. No claim of “healthy” or “fixed” without evidence.
VI
Model migration without regression
Failure
The primary reasoning model was scheduled to leave the subscription with three days’ notice. Swapping models blind had burned the system before — same prompts, different failure modes.
System Upgrade
An eval harness came first: golden tasks, a scoring rubric, a quality bar, and a candidate-vs-baseline diff. Migration became a measured decision instead of a hope. Skills that scored low got patched, not blamed.
// receipts that matter
Not “how many apps did AI make?” The receipts that matter are decisions: what got shipped, what got killed before it cost anything, and whether the system got harder to fool.
0
Shipped live
Two more killed before a line of code was written
0
Killed before code
The cheapest expensive decisions the system made
0%
Cost reduction
OpenRouter burn after routing discipline
0
Dated postmortems
Every failure became architecture, on the record
08 · Product Bets
Product bets managed through the operating loop. The impressive part is not that several things shipped. In 2026, shipping small apps quickly is table stakes. The interesting question is what changed in the product process: what got researched, killed, reframed, delegated, verified, and learned.
Cherry Street Labs became the studio layer: the public container for the experiments, the shared infrastructure, and the lessons moving from one product to the next.
Product Question
Can a daily history game create a Wordle-like habit loop?
My Role
Defined the product thesis, difficulty arc, acquisition logic, retention lens, quality bar, and release decisions.
Romulus’ Role
Spec generation, puzzle structure, CLAUDE.md, build coordination, verification, and deployment flow.
Outcome
A live daily history game with 90 puzzles seeded, localStorage-only state, seven-day difficulty arc, share card, and retention metrics instrumented for D7/D30/D90.
Delegation works best when the product shape is constrained.
Product Question
Is there room for a mobile-native party game between Heads Up and Taboo?
My Role
Interpreted contradictory model feedback, rejected the initial framing, chose the sharper mechanic, and set validation criteria.
Romulus’ Role
Multi-model pressure test, competitor framing, category research, thesis critique, and funnel architecture.
Outcome
Reframed from “digital Taboo” to a constraint-based pass-the-phone party game. Built an 862-card corpus across six themes and a web validation funnel for iOS intent.
The best AI-assisted product work is not confirming your idea. It is changing the idea before you waste build time.
Product Bet III
WaitLayer
Beta
Attention network for AI agents
Agent Surface
Product Question
When agents do the work, where does human attention go?
My Role
Defined the thesis, the trust boundary, the developer-experience bar, and the milestone gates. Chose what M0 had to prove before M1 earned investment.
Romulus’ Role
Competitive landscape research, spec drafting, build coordination through the delegation loop, verification, and milestone tracking.
Outcome
An attention network for AI coding agents: a CLI and runtime layer that routes agent wait-states to the human who can unblock them, with privacy-safe events. M0 shipped and in beta; M1 gated on beta signal, not enthusiasm.
The most AI-native product surface is the one the agents themselves need.
Product Bet IV
Via
Built · Parked
Built April 17–18, 2026
Fullstack Build
143files
18API routes
28passing tests
Product Question
Can the delegation loop handle a real fullstack product surface?
My Role
Defined scope, UI direction, quality bar, fix priorities, staging review, and product calls.
Romulus’ Role
A product spec tight enough that implementation ran without mid-build clarification, plus execution monitoring, verification, commit/report loop, and P0/P1/P2 fix tracking.
Outcome
AI-powered Gmail client: 143 files, 18 API routes, 28 passing tests, OAuth, Prisma, calendar integration, read receipts, smart triage, and a liquid-glass design system. Parked deliberately: the build proved the delegation loop at fullstack scale; shipping it as a product was a different bet with a different market, and the system’s job is to keep those honest.
The quality of the build depended on the quality of management. I did not hand-write production code; I owned direction, spec, review, and release decisions.
Research Bet V
AgentForge
Research Complete
Build Queued
Research Map
15beta testers
DeFihighest-scoring vertical
MCPhosted thesis
Product Question
Is hosted MCP infrastructure for DeFi agents a real wedge?
My Role
Set validation criteria, interpreted the signal, scoped the MVP, and held the build until the thesis cleared a higher bar.
Romulus’ Role
Research pipeline, Grok validation rounds, competitor teardown, X-signal analysis, and beta tester identification.
Outcome
Research complete, build plan written, 15 beta testers identified, DeFi/trading selected as the highest-scoring vertical, and a hosted MCP thesis formed before code was written.
AI leverage is not just building faster. It is deciding what deserves to be built.
Postmortem VI
Legion
Postmortem
Phase 2A
Phase 1 live
Cohort Map
Product Question
Can specialized AI cohorts sequence research, build, monetization, and distribution in one managed pipeline?
What Worked
The research cohort worked. It could take a raw product idea, research the market, map competitors, score opportunity, and return a structured build spec in Discord.
What Broke
Complex handoffs failed at the seams. A native iOS build exceeded the 15-minute timeout, downstream cohorts never ran, and task state did not survive the failed handoff.
My Role
System designer, orchestrator designer, failure analyst, postmortem owner, and Phase 2A planner.
Romulus’ Role
Coordinator across four specialized cohorts — research, build, monetization, and distribution — with Romulus deciding sequence.
Phase 2A Response
Durable task state, tiered timeouts, checkpoints, retries, and evals. Tier 1 for small tasks, Tier 2 for medium builds, Tier 3 for complex builds with checkpoints instead of a single brittle timeout.
The architecture was promising; the substrate was not ready. Knowing the difference is engineering maturity.
Product Question
Can the studio layer make the experiments legible enough to feel like a product practice, not a pile of side projects?
My Role
Defined the studio identity, visual direction, positioning, and role as the public container for the product lab.
Romulus’ Role
Build coordination, iteration support, deployment flow, and model-routing stabilization across the work.
Outcome
A live studio site that gives the product bets a shared surface, visual language, and operating context. The site is less a portfolio wrapper than a product lab identity system.
The work needed a public surface and a coherent studio frame. Cherry Street Labs became the container that made the operating model visible.
// also shipped through the loop, between the bets
Live · Open Source
Every publicly-reported rat sighting, inspection, and 311 complaint in New York, on one free map.
Live
Caveat
AI contract analysis — a plain-English risk read on anything you're about to sign.
App Store
Bible Path
A daily scripture companion, taken from spec to Apple review through the delegation loop.
Live · Same-Day Build
Knicks Parade Cam
Live street cameras along the Canyon of Heroes — conceived, built, and shipped the day of the parade.
09 · What Changed
The system's real output was a sharper operator.
Romulus made the cost of ambiguous thinking obvious, daily, and billable.
A vague ask produced a vague spec, which produced a vague build, which produced a rejected review — my time, wasted by my own imprecision. Five months of that feedback loop trains you the way real management does: goals, constraints, acceptance criteria, and what good looks like, defined before anything runs.
Before
- Vague asks created vague outputs.
- Research chased trend heat and market size.
- AI sessions reset context every time.
- No systematic model routing.
- No durable memory system.
- Build speed was easier to measure than build quality.
After
- Specs became contracts.
- Product bets were validated before build.
- Memory became infrastructure.
- Models were routed by job, cost, and failure mode.
- AI output was inspected, not accepted.
- Failures became postmortems and system upgrades.
Any AI-native team needs this operating layer. Most don’t have anyone who has actually built one.
10 · What I'd Do With a Real Team
Every primitive here scales from a team of one to a team of forty.
The advantage will not go to teams with the most AI tools. It will go to teams where someone has designed the operating model around them — and most teams haven't.
On day one, that looks concrete: specs written as contracts agents and engineers can both execute. Work routed by capability, cost, and failure mode instead of habit. Evals built before migrations, not after incidents. Memory designed so context compounds across sprints instead of resetting. A verification gate no output crosses without evidence — human or synthetic.
I didn't read about these primitives. I ran them for five months, alone, under real constraints, with receipts. The next version of this system gets built inside a team — where the leverage multiplies.
The products are evidence. The operating model is the point. The operator is the part that transfers.