Case Study · AI Software Studio · Build + Enable

41 apps built. 10+ dev teams enabled.

Your developers already have Claude. They already know they can build anything — they’re doing it right now, faster than review, security, and architecture can keep up. What they need isn’t inspiration. It’s guidance, safety, and oversight — from a practice that ships with these tools every day: 41 apps built, 10+ development teams enabled, velocity up for every one of them.

Built: 41 apps — 11 commercial · 30+ personal Enabled: 10+ software & product companies Cadence: 30-day builds · weekly revisions in writing Outcome: Velocity up, every team

Apps built — for clients, companies, and individuals who wanted software that fits their life

30 days

Idea to working app, with weekly written revision checkpoints

10+

Software companies enabled — dev teams and architects, from the copilot era into the agent era

Every team

Increased velocity, agile-measured against captured pre-AI baselines

The situation

Your developers just got Claude.

Somewhere in your company an internal champion put AI on the team’s desks — and it worked. Within a month the whole team is building everything under the sun, faster than review, security, and architecture can keep up. The enthusiasm is the asset. Unmanaged, it’s also the exposure: unreviewed generated code heading for production, sensitive context leaving the building, architecture decisions delegated to a model nobody’s verifying.

Your team doesn’t need to be told what’s possible — they’re living it. What they need is guidance on where AI belongs in the system, safety in how it gets used, and oversight that proves it’s working. That’s this practice. We’ve run it for 10+ software and product companies, since before agents existed.

What we install

Guidance. Safety. Oversight.

Guidance — fit AI to the team, not the team to AI

We start from your team’s own cadence — AI goes into the sprint, not the sprint around AI — and we work with the architects, not just the coders. The riskiest AI decisions aren’t in the diffs; they’re in the designs. Knowing where AI belongs in a system — and where it doesn’t yet — is most of the job.

Safety — habits, not memos

Human review before generated code merges. Clear rules for what context can and cannot leave the building. Verification as a first-class step, not an afterthought. The habits are simple; the work is making them team habits instead of individual virtues.

✓ No incidents traced to installed practices

Oversight — a scoreboard everyone already trusts

Baseline captured before AI touches anything, then adoption measured the way agile teams already measure themselves: velocity. It rose for every single team — and because the baseline came first, nobody has to take that on faith.

✓ Baseline first, always

And it’s written down

What we kept teaching team after team, we published: the AI Manifesto. In the agent era the same discipline continues as skill security and agent governance — read what we hold ourselves to before you hire us.

✓ Published · free

What mature looks like

The endgame: your own champion, teaching.

The engagement is working when we’re no longer the ones presenting. At one current client, a few months in, their own senior engineer ran the AI dev-practices session for the whole team — our written guidance, contextualized to their systems, in his voice, on his slides. That’s the durability you’re buying: adoption that doesn’t depend on us being in the room.

What that team now teaches itself:

Plan first, then codeGoal + context → scope + non-goals → risks + assumptions → acceptance criteria. The more powerful the coding agent, the more important the planning step becomes.

Ground the agent in the repoDon’t make the agent rediscover the project every time. A short CLAUDE.md — a table of contents and a behavioral contract, not a junk drawer — pointing at architecture, current state, and what’s next.

AI mistakes compileThe dangerous errors look reasonable and still violate intent — a swapped digit, a plausible wrong assumption, a misread config. So the workflow forces verification: deterministic checks, review gates, tests.

Why listen to us

Because we ship, too.

This isn’t advice from the sidelines. 41 apps built with AI — 11 commercial, all under NDA, several in production; 30+ personal, many born at our live workshop’s open-build floor. Thirty days each, a working build every week, revisions in writing. Every practice on this page runs in our own production systems first.

Need the app built rather than the team enabled? Same practice, same cadence — and honest platform advice up front: most “apps” ship best as mobile web apps, PWAs, or Chrome extensions. We build native when the product demands it, and say so when it doesn’t.

The discipline

The engineering system behind both sides.

None of this runs on vibes. Every build and every enablement ships the same operating system — rules we run on our own production systems daily, written the hard way, and installed into every client team we touch.

The 30-day build cadence

A working version every week, revisions in writing every week. Momentum plus a paper trail — no big reveal in week four.

Nothing merges unreviewed

AI implementsthe agent writes the code

Independent review reads the codea second set of eyes — never the implementer’s summary of it

Spec first, quality second“built the right thing” before “built it well”

Human mergesa person owns the decision, every time

Definition of done — 3 layers

1 · It reads rightstatic checks pass, no obvious errors

2 · It runs righttests green, the app actually starts

3 · It works end-to-endthe whole flow completes — “code written” is not done

A feature is done when its verification command runs green — the system records the evidence; nobody self-declares.

Where’s the verifier?The first question of any automation. No deterministic pass/fail check? Then it doesn’t run unattended.

Baseline before AI touches anythingWithout a captured pre-AI baseline, “AI improved X” is unfalsifiable theater. Standing up the metrics is itself the first win.

Root cause first, alwaysSymptom fixes are failure. One hypothesis, the smallest possible change — and three failed fixes means it’s architectural, so stop and rethink.

Never edit the expected valueA failing assertion gets a cause investigated — not its expected number quietly changed to make the test pass.

Failing test firstNew feature: write the test that fails, then make it pass. Bug: reproduce it in a test before fixing it.

Fix the generator, not the outputA recurring bug in generated artifacts gets fixed once at the source — never patched in output the next run overwrites.

Fail loudly, never silentlyNo swallowed errors in CI, no “green” pipelines that pushed nothing. If it matters, it fails loudly or proves it succeeded.

Audit the harness, not the modelWhen an AI system underperforms, fix the guardrails, state, and verification loop before reaching for a bigger model.

These aren’t aspirations — they’re the standing rules of our own production systems, and the operating system every enabled team leaves with.

What we can claim

Honest numbers, both sides.

Straight talk: the enablement practice largely predates agents — and predates our habit of banking dollar figures. We won’t retrofit revenue claims onto engagements that didn’t track them. What was measured rigorously was velocity against a captured baseline — and on the build side, shipped software on a written cadence.

41 shipped

The build side. 11 commercial apps (under NDA, several in production) + 30+ personal apps — 30 days each, weekly revisions in writing.

Every team faster

The enable side. 10+ software companies, velocity up across all of them — agile-measured, baseline-captured, safely adopted.

Safely

Review gates, context rules, verification habits — adopted as team discipline, no incidents traced to the practices we installed.

Public

The playbook’s principles published as the AI Manifesto — read what we hold ourselves to.

Why it works

Your team doesn’t need to be told what’s possible. They need someone who’s already shipped through every failure mode.

Adopt fast, verify always

We never slow the enthusiasm down — we give it a verifier. Generated code merges when a human has read it.

Honest platform, honest metric

PWA or native, we recommend what serves the product. Velocity or shipped software, we claim only what was measured.

Whole systems, not screens

Data model, workflow, legal posture where it matters. An app is the visible tip of a system that has to hold up.

Weekly, written, working

A working build every week and revisions in writing — on both sides of the practice. Momentum plus a paper trail.

Your architects just got Claude…

…and they want to build everything under the sun. Good — that energy is the whole opportunity. Whether you need software built or a team enabled to build it safely, that’s this practice. And if it’s the personal app you’ve always wanted: come build v0.1 yourself at the Builder’s Table.

Start a conversation → Build it yourself, live →