The rule
Every line of code we ship goes through a human. Every one. That's not a marketing line — it's an engineering rule with real teeth, because AI is genuinely bad at some things and would happily wreck a client's production database if we let it. What AI is great at, we lean into hard. What it's bad at, we don't hand it the keys.
AI drafts. Humans decide. Every commit is authored by a person, and every diff is read before it ships.
Where AI is fastest
On a typical Doyel Labs build, the following categories are 80–95% AI-drafted. We prompt with the shape of what we need, review the diff, and land the code:
Boilerplate scaffolding
Next.js pages, React components, Tailwind classes, form stubs, schema.org JSON-LD blocks, migration SQL, seed scripts.
Repetitive translation
"This spreadsheet is now this table." "This Figma frame is now this TSX." "This English spec is now this validation schema."
Test fixtures
Realistic-looking demo data, edge-case inputs, synthetic users, mock API responses. AI is genuinely great at generating "stuff that looks real" without touching production data.
Copy that isn't legal or medical
Marketing headlines, product descriptions, form placeholders, empty-state text, changelog entries. First draft in seconds; a human edits for voice.
Format conversions
CSV to JSON, YAML to TypeScript, HTML to Markdown, one logger's output format to another's. AI reads the shape, spits the transform.
Documentation
README updates, inline code comments, API docs, handover notes. AI drafts to match the codebase style; a human adds the "why" sentences a future reader needs.
Where humans still own it
These are the categories where a wrong answer isn't a typo — it's a real problem for a real client. AI can help scaffold, but the final call is a person's:
Anything that moves money
Payment integrations, refund logic, invoice states, payout math. If the code decides how many dollars move, a person writes it and a person reads it.
Compliance code paths
SCA floor checks. Tax-adjacent math. HIPAA-adjacent access rules. Anywhere the wrong branch is a regulator problem, humans hold the pen.
Security-critical logic
Auth flows, session handling, permission checks, secret loading, rate limits, WebAuthn ceremony code. AI is confidently wrong on these often enough that we treat its drafts as a red flag, not a green light.
Legal + medical claims
Any sentence that would need a lawyer's review is written by a human — or by AI and then rewritten. We would rather ship less copy than ship copy that overstates what the software does.
Data-destructive operations
Migrations that drop tables, delete users, or truncate rows. AI writes the draft; a person reads it in staging; only then does it touch production data.
Product judgement
"Which of these three UX patterns is right for this operator?" is a human call. AI has taste; it does not have your client.
How we keep clients safe when AI drafts real code
We've worked out five rules over enough builds that we apply them without arguing:
- 01
AI never has a production key.
No AI tool we run has direct access to a client's live database, payment provider, email sender, or DNS. Every credential lives in a scoped secret store, and only the person shipping the deploy pulls it.
- 02
Every commit is authored by a person.
Git history shows a human name and email. AI is a drafting tool inside a person's editor, not a separate committer with its own trust level.
- 03
Diffs are read before merge.
Every pull request opens with a diff a person reads top to bottom. If AI wrote a hundred lines and only ten of them were the answer, the ninety go in the trash — not into the client's repo.
- 04
Dangerous paths get tests, not vibes.
Any code that spends money, moves data, or enforces a compliance rule ships with a test that pins the behaviour. If AI regenerates that code later and the test breaks, the code is wrong — not the test.
- 05
Staging comes before production.
Every migration, every destructive operation, every third-party integration lands on a preview URL or a staging DB first. Production is the last step, not the debugging environment.
Why this matters to a client
Two reasons. First — speed. AI-drafted scaffolding, tests, and copy compress a two-month build to a two-week one. That's how we can quote fixed prices for work that other agencies would price by the hour: our hours are just fewer.
Second — quality. Because the boring parts are AI-fast, the interesting parts get the human attention they deserve. The floor check on your payroll app, the authentication ceremony on your customer portal, the copy that a lawyer might one day squint at — those all get read carefully, because we're not tired from writing the boilerplate that led up to them.
A short list of things AI does not do here
AI does not decide what to build.
AI does not talk to your customers.
AI does not sign off on a launch.
AI does not touch legal text.
The one-line version
If any of this matches how you'd want a software build to run, email us. If it doesn't, email us anyway — sometimes the whole point of a first call is to figure out whether we're a fit.
Start a project
One paragraph on what your business does and what you want built. Written scope and fixed price back to you within one business day.