I built a regulated healthcare platform solo. The interesting part is how.

The method: vibe coding, with guardrails

The headline writes itself — one person, an AI, a regulated platform, a few months. The headline is also the least useful part. Generating code quickly is now table stakes. The question that actually matters is whether what comes out survives contact with production, an auditor, and the next six months of changes. Here is the discipline that made it hold.

• Claude wrote most of the code. I directed it. The build ran on Claude as the engine — components, services, tests, migrations — with me scoping the work, reviewing every diff, and owning the architecture. Speed came from the AI. Judgment did not.
• The AI operates under written law — and inside a hard perimeter. Two layers of constraint, not one. The law is a set of rule files the agent reads every session: migration conventions, row-level security required on every table, the single approved path for version tracking, and "traps" logged from past mistakes so it cannot repeat them. The perimeter is the harness itself — the agent may only run an approved set of commands, and a hook physically blocks any push to the production branch without my hand on it. In a regulated build, that approval-gating is not a convenience; it is the audit-trail control surface you point an auditor at. Constraints are not a limit on the system — they are what make it safe to employ.
• Nothing ships red. Every change moves through issue → branch → pull request → CI. The pipeline runs lint, a strict TypeScript typecheck held at zero errors, the full test suite, and secret scanning. A pull request that fails any of them cannot merge. Staging merges itself on green; production merges only when I read the diff and click the button myself — the recorded, pre-implementation approval that regulated change control expects.
• The AI built against contracts, not into a monolith. The fastest way to drown in AI-generated code is to let it all pile into one app — which is what most first builds quietly become: a tangled mess that fights you every time you try to fix or extend it. This codebase is eleven packages behind explicit interfaces. Give the agent a defined contract and its output conforms to a boundary instead of coupling to everything in reach. Modularity is how you keep an AI's speed from turning into an AI's mess.

None of this is exotic tooling — it is the configuration layer most teams skip. In a study of 2,853 repositories, the typical project configured almost nothing beyond a single context file; only 158 used agent skills at all, and few used hooks or subagents. This build used seven of the eight mechanisms the study catalogs. In a regulated domain, that configuration layer is the difference between an assistant that suggests and a system you can trust to act. (Galster et al., Configuring Agentic AI Coding Tools, arXiv:2602.14690)

The numbers

What that method produced, all of it verifiable in the repository:

116K+

lines of TypeScript

339

commits, solo

1,245

automated tests

68

database migrations

11 + 2

packages and apps

0

TypeScript errors

Where it breaks — and how I caught it

The first place an AI build breaks is not the code. It is the brief. An AI executes the order it is given — and if the order is incomplete, it fills the gaps itself, confidently, in ways that make sense to the model and not to your product. A system tested for ten users and never told to expect fifteen thousand gets built for ten. That is not an AI failure; it is a requirements failure, and it would sink a hand-written build just as fast. Knowing which assumptions to shape before you prompt is the actual skill — and the reason this platform was built for production, not for the demo.

The second place it breaks is the code itself. AI-generated code is fast; it is not automatically correct, and in a regulated domain "mostly correct" is a liability. So before any wider rollout I ran a multi-agent review against my own codebase — separate passes for security, database, and user experience. It surfaced 82 issues, six of them critical. Every one was fixable, and every one was fixed before rollout.

That is the point. A solo developer with an AI and no guardrails ships those 82 issues — and builds the ten-user version of the system. A solo developer with an AI, a sharp brief, and a review gate ships neither. The velocity is the AI; the safety is the discipline layered on top of it — and the gap between "the AI made it fast" and "the AI made it right" is the whole game.

What this means for you

This is the engagement, not a war story. The same method is what Coyote & Quill brings to your problem.

• Custom App Development — a working, compliance-aware application built and shipped, not a strategy deck about one. Built the way this one was: modular, tested, audited, and yours.
• The Vibe Coding Workshop — your team builds a real, deployable tool with AI in the room and leaves with the operator's playbook: how to direct the agent, where it breaks, and the guardrails that keep its output from shipping broken. The discipline above is the curriculum. This platform is the proof it works.

If your team is adopting AI-assisted development and the stakes are real — regulated data, production systems, an audit on the horizon — the speed is the easy part. The discipline is what you are buying.

AI made one person as fast as a small team. The discipline is what kept the output shippable. You can have both — that is the entire pitch.