digitalworker-docs

Why DigitalWorker?

Fast read: read the headings and bold text for the main message, evidence, and next steps. Read the surrounding text for detail; open the expandable sections when you want more.

Written for: developers, non-developer builders, and business owners — outcomes, examples, and ways to evaluate DigitalWorker; internals: engineering deep dive.

---

---

AI wrote the code. You’re cleaning up. Let DigitalWorker handle the cleanup.

You make the decisions that matter. DigitalWorker turns a task card into a tested, reviewed, production-ready¹ pull request — professional-developer output, not AI intern drafts. It’s like assigning a top-10% developer to a well-scoped task — at AI cost.

No iterative prompting. No babysitting. No cleaning up after the AI.²

Saving the world from spaghetti code.

Two products:

• DigitalWorker Reviewer — review your existing pull requests.
• DigitalWorker Agent — delegate the whole task.

You’re Doing AI Coding Slow!

The assumptions behind DigitalWorker - why we developed it:

• Current AI generates average code and architecture — sloppy, disorganized, badly engineered — because it was trained on median human code — and most human code, public or private, ignores object-oriented design discipline, layering, and automated test coverage
• Without working architectural guardrails, AI prints technical debt at machine speed — reliably enforcing an engineering process on AI is a difficult, unsolved problem
• Guiding AI to convert its spaghetti code and broken architecture takes a lot of hard manual labor, technical knowledge, and skill — reviewing, fixing, re-prompting — not just more AI usage. This is the main reason AI agents improve shipping speed only marginally — controlled research puts real-world gains at ~25% at best, not manifold³
• If a software solution is built with AI by a human who never fights back the AI slop, complexity limits are reached quickly: within as little as one month the AI’s pace of change plateaus and the defect count becomes unmanageable
• Even if a team of humans fights back using AI to review AI code, gives AI code standards, some architecture and instructions on how to review code, the slop still overwhelms at scale — review capacity becomes the bottleneck, new features break existing ones, and the codebase converges to a plateau where only long-frozen features are dependable.⁴
• Current AI has severely impaired judgment which manifests in constant confusion about the real world
• Current AI absolutely cannot be trusted to make important decisions
• AI will not fix itself without competent help from human experts: AI often knows what the best practices are but does not follow them anyway, even when you explicitly ask it to. Current AI is nowhere close to AGI — AI that can do any job a person can — and no known architecture changes that anytime soon.
• Cheap AI generation does not make code quality matter less — it makes it matter sooner: AI struggles against spaghetti even harder than human maintainers do — context limits and compounding errors hit hardest on large, messy codebases. Controlled research found experienced developers ~19% slower with AI on their own mature repositories³
• Engineering discipline is not a tax on speed — past a few thousand lines it is the speed: in a peer-reviewed study of 39 production codebases, low-quality code carried 15×(!) more defects and took approximately 2.2× as long to resolve issues⁵
• As generation cost falls, the binding constraint shifts to whether the code can be changed at all — making scalable, maintainable software the decisive economic prize

What we claim as possible

• Nevertheless, the problem above has a better solution and current AI can be asked to run checklists with hundreds of items and produce much better structured code that is actually easy to follow, easy to change, with pretty good mutation test coverage, and that scales almost linearly with complexity.
• The catch is that AI will not follow such huge checklists if they are given to it as pure text and in a generic fashion. However, checklists coupled with a smart, adjustable Instruction Engine can make AI follow every instruction.
• Also, current AI can be asked to make most important decisions upfront in a dry-run fashion, which allows humans to unconfuse AI early by overriding those decisions as needed (and optionally explaining rationale)

You make the decisions that matter. Build software you’re proud to put your name on.

Substantially fewer defects. Far less cleanup. More uninterrupted attention for the product you want to build.

Your engineering competence sets the standard. DigitalWorker carries it through the work: turning a task card into a tested, reviewed, production-ready¹ pull request. You shape the pivotal decisions and perform the final behavior check; DigitalWorker handles implementation, testing, review, and fixes.

Take pride in maintainable and beautiful work: clear intent, well-organized parts, and code you can confidently extend.

See the task and the resulting pull request: compare the source task cards with the generated code and pull-request/fix history. Two demo applications, generated from task cards, with spot-reviews and external defect feedback disclosed.

Verify our claims — no account or setup needed

See the engineering behind the result — the method, concrete code examples, comparison criteria, and economics. No signup required.

Developers: jump straight to the recorded evidence or the engineering deep dive. For the engineering details, open the technical blocks below.

---

Two products. One engineering standard.

1. DigitalWorker Reviewer — Keep your coding tools. Catch the AI slop before merge.

   You asked for TDD, OOP and proper testable layers. Your AI drifted to bloated, disorganized slop anyway. DigitalWorker Reviewer detects Agile architecture violations such as incorrect layer dependencies and Anemic Domain Model anti-pattern, testability issues, test coverage gaps, and most code smells including code and class duplication. The Reviewer comments; it does not change your code. No Trello required.

   Install the Reviewer — ~1 minute.

2. DigitalWorker Agent — Hand off the task. Get code implemented, reviewed, and refactored against the same architecture and maintainability standards.

   Try the Agent — $15 credit included.

The Reviewer uses the same review engine the full Agent uses on its own work. Use either product on its own.

Why it’s different

• A combination found nowhere else that we know of — the AI follows a rigorous engineering process precisely instead of improvising, and applies the discipline a senior engineer would.
  Show details

  A combination found nowhere else that we know of: it makes the AI follow a rigorous engineering process precisely instead of improvising, and it applies the discipline a senior engineer would — design decisions before code, checks before implementation, a rigorous review of every change, and no duplicate structures. Other agents can code, test, review, and submit changes for approval; DigitalWorker carries the complete engineering method through delivery. Inspect the difference.

  The technical version

  You asked for TDD and OOP. Your AI drifted anyway. DigitalWorker makes those disciplines part of delivery: test-first implementation, architecture review, refactoring, and fixes, carried by its proprietary instruction engine. A task card becomes a tested, reviewed PR for your final behavior check. You keep the decisions that matter. Try one real task—$15 credit included.

  A combination found nowhere else that we know of: high-precision instruction enforcement plus this depth of Agile, OOP, test-first TDD, review, and anti-duplication class design. Other agents can code, test, review, and open PRs; DigitalWorker carries the complete engineering method through delivery. Inspect the difference.

• Get relief from repeated review and repair — fewer defects, far less cleanup, and a light human check instead of line-by-line review.
  Show details

  Fast generation helps only when the result moves your product forward. DigitalWorker makes quality work part of delivery: it writes the checks before the code, reviews its own work against a ~100-item engineering checklist, then cleans up and fixes before handing you the change. You receive the code, the tests, and the reasoning behind the decisions together.

  The sequence is explicit: a check of the intended behavior that fails first → the smallest change to pass it → review, cleanup, fixes, and re-checks. See how the method earns the outcome.

  Stop paying the AI bug tax. We observe substantially fewer defects and far less cleanup than AI coding without this enforced process. In founder production use, hands-on oversight is dramatically lower: make a fast human check of decisions and trade-offs, inspect the key code that implements your business rules, then check the final behavior. Routine code does not need line-by-line review in that operating experience.

  The technical version

  Fast generation helps only when the result moves your product forward. DigitalWorker makes quality work part of delivery: enforced test-first TDD, a dedicated ~100-step checklist-driven review (correctness, architecture and standards, code-smell detection, requirements audit), refactoring, and fixes before the PR. You receive the code, tests, and design decisions together.

  The sequence is explicit: a failing behavior test → the minimum implementation to pass → review, refactoring, fixes, and re-checks. See how the workflow earns the outcome.

  Stop paying the AI bug tax. We observe substantially fewer defects and far less cleanup than AI coding without this enforced pipeline. In founder production use, hands-on oversight is dramatically lower: spot-review the decisions and key domain code, then check the final behavior. Routine code does not need line-by-line review in that operating experience.

  “Production-ready” means the implementation has completed the engineering workflow and is ready for your final hands-on check. Founder-observed results are not an independent benchmark or a defect-free guarantee for every repository.

• Keep control of consequential decisions — your judgment decides the plan, assumptions, and pivotal design; the implementation review is carried for you.
  Show details

  You choose what to build, what “done” means, and the trade-offs you can live with. You no longer review for defects — DigitalWorker’s own reviews and checklists handle that; your review is judgment, placed early, before implementation. Review the proposed plan, assumptions, and pivotal design decisions. Before new parts of the code are created, inspect their proposed responsibilities and how they relate; correct the design where needed. DigitalWorker executes the engineering work through its proprietary Instruction Engine.

  For non-developers, the starting point is the plan and a plain description of what “done” looks like. You can delegate implementation and routine design; novel or complex design still benefits from an experienced developer’s judgment. You keep the final check that the software behaves as intended before the change is combined with your existing code.

  The technical version

  You choose what to build, the acceptance criteria, and the trade-offs you can live with. You no longer review for defects — AI reviews and checklists handle that; your review is judgment, placed early, before implementation. Review the proposed plan, assumptions, and pivotal architecture decisions. Before new classes are scaffolded, inspect their proposed responsibilities and relationships; correct the design where needed. DigitalWorker executes the engineering work through the proprietary Instruction Engine.

  For non-developers, the starting point is the plan and acceptance criteria. You can delegate implementation and routine design; novel or complex architecture still benefits from an experienced developer’s judgment. You keep the final behavior check before merge.

• Build something beautiful that stays maintainable — clear intent, focused parts, and business rules kept separate from the technical details.
  Show details

  Beautiful software makes its intent easy to understand. DigitalWorker looks for concepts your code already has before inventing new ones, keeps each part focused on one clear job, and keeps rules and the data they act on together. It separates your business rules from the technical details — so the logic stays easy to read, test, reuse, and change — and prunes needless complexity and duplicate structures.

  In the Calculator demo, one part of the code holds the calculator’s current state and handles button presses through one clearly named action. The code that interprets mathematical expressions stays inside the part that needs it. The tests check the edges — numbers too large for the calculator to handle, and what happens after an error locks it. These are concrete examples of the clarity and care you can inspect. Explore the code and edge-case tests.

  This always-on engineering discipline prevents almost all technical debt in founder-observed production use. Its method reflects more than 20 years of disciplined software development and two years of refinement with AI coding agents. The payoff extends beyond the next change: a codebase you can take pride in as features, integrations, customers, and business rules multiply and grow.

  On well-scoped tasks, we expect DigitalWorker to match or exceed the output of the top 10%⁶ of professional developers

  The technical version

  Beautiful software makes its intent easy to understand. DigitalWorker searches for existing domain concepts before adding classes, checks cohesion, and brings behavior and state together in Rich Domain Models. It applies Clean Architecture — business rules separated from frameworks, UI, and databases for easy testing and reuse — KISS, DRY, and YAGNI, pruning unnecessary abstractions and duplicate structures.

  In the Calculator demo, Calculator owns its state and behavior through Press(InputKey); the parser stays inside MathExpression. Tests exercise overflow boundaries and the behavior of a locked error state. These are concrete examples of the clarity and care you can inspect. Explore the code and edge-case tests.

  This autonomous engineering governance layer prevents almost all technical debt in founder-observed production use. Its method reflects more than 20 years of Agile and OOP practice and two years of refinement with AI coding agents. The payoff extends beyond the next PR: a codebase you can take pride in as features, integrations, customers, and business rules multiply and grow.

  On well-scoped tasks, we expect DigitalWorker to match or exceed the output of the top 10%⁶ of professional developers

• Put your expertise into more ambitious work — top-10% professional-developer output⁶ at AI execution cost.
  Show details

  Top 10% professional-developer output⁶ at AI execution cost.

  Direct your judgment toward the product while DigitalWorker handles routine implementation and quality work. The current usage model is model cost plus around 20% markup; see the economics and how to evaluate total effort.

  Enforced discipline is not overhead—it is why velocity does not slow down as the codebase grows. In founder production use, a greenfield system with 4,000 automated tests and 53,000 lines of code reached production in 5 months. A parallel 51,000-line commercial codebase sustained ~85 commits per month for nearly a year without throughput degradation.

  Experienced developers can take on more design work, product decisions, and quality leadership while retaining the parts of engineering they enjoy. Non-developers can turn clear requirements into working software and bring in experienced judgment for consequential design choices. The opportunity is to build more of what matters to you, with competence visible in the result.

• Instruction-following is the hard problem, especially when going against training data. But our breakthrough: the Instruction Engine — virtually solved it for its engineering process in founder-observed production use.
  Show details

  AI learns from existing code — including its bad habits. In our production work, models repeatedly drift back to bloated spaghetti code and copy-pasted duplicates even when explicitly told not to. A well-written instruction does not ensure it will survive a long task.

  Agent skills help. Yet even top-tier models struggle with long sequences of instructions: losing track partway through, dropping requirements, piling mistakes on earlier mistakes, or claiming actions they never took. These failure modes are documented industry-wide — research on iterative coding tasks shows agents erode code quality over long tasks, and agents have been observed bypassing mandatory process requirements even under explicit “never skip” guardrails. Keeping the entire procedure on track is a substantial engineering problem.

  But DigitalWorker has virtually solved instruction-following for its engineering process in founder-observed production use. Its proprietary model-adaptable Instruction Engine keeps every required instruction in force through the whole task — design, implementation, testing, review, and repair — with two years of refined engineering rules behind them.

  That is the capability to evaluate when comparing it with agent skills: sustained execution of the whole method. Inspect the delivered work and its fix history, then judge it on a bounded task of your own. “Virtually solved” describes practical reliability in our engineering process; it does not promise that every model action is infallible.

  The technical version

  AI learns from code that includes anti-patterns. In our production work, models repeatedly gravitate back to procedural designs, duplicated classes, and anemic domain models — objects that hold data but contain no behavior, violating object-oriented design — even when explicitly instructed otherwise. A well-written instruction does not ensure it will survive the whole execution chain.

  Agentic skills help by packaging instructions, examples, and tools. Yet even top-tier models struggle with long, multi-step instructions: losing context, dropping requirements, compounding earlier mistakes, or hallucinating tool calls. These failure modes are documented industry-wide — research on iterative coding tasks shows agents erode code quality over long horizons, and agents have been observed bypassing mandatory workflow steps even under explicit “never skip” guardrails. Keeping the entire procedure on track is a substantial engineering problem.

  DigitalWorker has virtually solved instruction-following for its engineering workflows in founder-observed production use. Its proprietary model-adaptable Instruction Engine keeps the design, implementation, testing, review, and repair instructions in the execution path, with two years of refined engineering rules behind them.

  That is the capability to evaluate when comparing it with agent skills: sustained execution of the whole method. Inspect the delivered work and its fix history, then judge it on a bounded task of your own. “Virtually solved” describes practical reliability in our production use; it does not promise that every model action is infallible.

• Bring your own expertise beyond code — the same engine can carry your professional instructions, of any length.
  Show details

  The same engine can carry your professional instructions — of any length — and make AI execute them almost as if they were code. Write your process in a Markdown file and send it to us; we configure it for you for free.

  The full pitch

  The Instruction Engine’s purpose extends to your own professional methods. Developers, lawyers, marketers, and other professionals can bring their instructions in a Markdown file so the whole procedure is carried through. Your competence defines the method; the engine supports its consistent execution.

  Have a process with several stages that your AI keeps only partly following? Write your instructions in a Markdown file and send them to us. We will configure it for you for free. The built-in instructions are replaceable presets, not fixed: DigitalWorker currently ships software design and development related instructions, but swapping in custom instructions — for your own engineering method or for any other industry and profession — is trivial.

  Your instructions stay yours. They run through the same protected engine that guards our own proprietary instructions, and our AI provider stores nothing from our runs, so the instructions are never retained for model training.

  The technical version

  The Instruction Engine’s purpose extends to your own professional methods. Developers, lawyers, marketers, and other professionals can bring their instructions in .md format so the whole procedure is carried through. Your competence defines the method; the engine supports its consistent execution.

  Have a multi-step process that your AI keeps only partly following? Write your instructions in a Markdown file and send them to us. We will configure it for you for free. The built-in instructions are replaceable presets, not fixed: DigitalWorker currently ships software design and development related instructions, but swapping in custom instructions — for your own engineering method or for any other industry and profession — is trivial.

  Your instructions stay yours. They run through the same protected engine that guards our own instruction IP, and provider-side Zero Data Retention means they are never retained for model training.

• Fits the way you want to work — No repeated prompting and local setup; tasks run in parallel, decisions ship with the deliverable, managed AI infrastructure, replaceable discipline.
  Show details

  No repeated prompting, tasks are parallel while you focus elsewhere, decisions shipped with the code, managed AI infrastructure, a discipline preset you can replace with your own, and no local setup to start.

  Six ways it fits

  • No repeated prompting: Submit a task card and let DigitalWorker run. Review pivotal decisions when needed, without continuously driving implementation through chat.
  • Work can continue while you focus elsewhere: Several tasks can run at once, each in isolation, or arrive on recurring schedules through Trello’s Task Repeater.
  • Decisions accompany the deliverable: The design package records the decisions made, the trade-offs weighed, and the assumptions — so the reasoning arrives with the code.
  • Managed AI infrastructure: Each phase — planning, implementation, testing, review — runs on whichever AI model currently gives the best quality for its price, and the choice adapts as prices and capabilities change. The depth of the process matches the task: a small, well-defined fix avoids the cost of extensive planning. We provide access to the AI models and the credentials they require.
  • Opinionated but replaceable: The built-in engineering discipline is a preset, not a cage. Bring your own process — the same Instruction Engine carries your instructions with the same precision.
  • No local setup to start using it: Connect your GitHub codebase — optionally with a Trello board for task cards; Trello is not required if you use DigitalWorker purely as a reviewer of your GitHub changes. No software to install or command line to configure.

  The technical version

  • No iterative prompting: Submit a task card and let the workflow execute. Review pivotal decisions when needed, without continuously driving implementation through chat.
  • Work can continue while you focus elsewhere: Tasks can run simultaneously in isolated branches and environments, or arrive on recurring schedules through Trello’s Task Repeater.
  • Decisions accompany the deliverable: The design package records architecture decisions, trade-offs, class responsibilities, and assumptions.
  • Managed AI infrastructure: Each phase — planning, implementation, testing, review — runs on whichever model currently sits on the price/performance frontier for that kind of work, and the selection adapts as the frontier shifts. Process depth scales with the task too: a bounded fix doesn’t pay for a heavy planning pass. We provide the model access and API keys.
  • Opinionated but replaceable: The Agile, Clean Architecture, and OOP discipline bundle is a preset, not a cage. Bring your own engineering instructions — the same Instruction Engine carries them with the same precision.
  • No local setup to start using it: Connect your GitHub repository — optionally with a Trello board for task cards; Trello is not required when using DigitalWorker purely as the Reviewer GitHub App. No CLI configuration, IDE extension, or per-developer installation.

Founder Experience

I’ve used the AI engineering workflows behind DigitalWorker every day for two years. With those workflows, I’ve completed several production projects, each with many thousands of unit tests and AI-run code review and testing. They took very minimal prompting, and I wrote only a few lines of code by hand. All of them run smoothly in production today.

In my own production work, I delivered a greenfield system with approximately 53,000 lines of code and 4,000 automated tests to production in 5 months. In parallel, I sustained approximately 85 commits per month for nearly a year on a commercial codebase of approximately 51,000 lines, at constant effort, without throughput degradation.

The engineering results described here come from that daily production use. See the process in action in the public demo repo, including the tests, pull requests, and fix history.

Getting Started

Choose your product below. The Reviewer connects directly to GitHub; the Agent offers evidence, a public demo, and a private-board trial.

(You don’t need to read the docs first — wherever you meet DigitalWorker, on a card or on a pull request comment, you can just ask it how something works).

Get DigitalWorker Reviewer

DigitalWorker is the first reviewer that enforces full and proper Agile discipline and architecture in code — including Patterns of Enterprise Application Architecture such as Layers and OOP/Rich Domain Model, testability, and clean code without code smells.

Watch it review your real pull requests — GitHub only, ~1 minute

Show how

Install the DigitalWorker PR Reviewer GitHub App on a repository you choose. From then on every pull request — and every push to it — gets an automatic read-only review posted by digitalworker-reviewer[bot]: a scored summary, detected architectural issues, code smells and key risks, and inline comments on specific lines. You can also post @digitalworker review on any PR to trigger it on demand.

No Trello account, no personal access token, no code changes — and it uninstalls in one click from GitHub Settings > Applications. The Reviewer uses the same review engine the full DigitalWorker Agent uses on its own work: a ~100-item engineering checklist covering correctness, architecture and standards, code-smell detection, and requirements audit — on your real diffs.

Want to try it on a repo you own? Install it there directly. For a work repo, share the install link with your repository administrator or organization owner.

Try DigitalWorker Agent

Verify our claims — no account or setup needed

Show how

Browse the public source, source task cards, and PR history. Both applications were 100% generated by DigitalWorker from task cards. Human involvement consisted of fast spot-reviews and, for the Calculator, passing external review feedback into a fix card for autonomous remediation.

• Scientific Calculator: 230 domain unit tests, a Rich Domain Model, and explicit edge-case behavior. External review found issues, followed by autonomous remediation through a fix card.
• URL Shortener API: 40 unit tests, Clean Architecture, Entity Framework data access, and requirements traceability.

If you read the code like a senior dev, you’ll find: methods are short, parameters few, state and behavior live in the same classes, Domain depends on nothing, and coverage is near-complete.

Inspect the recorded coverage, execution times, human involvement, and recovery. The examples demonstrate the work delivered, not a guaranteed result for every task. Initial internal review did not catch every Calculator issue; the fix history shows what happened next.

To run the domain/API tests yourself, install the .NET 10 SDK and use:

git clone https://github.com/grandua/Digital-Worker-Demo.git
cd Digital-Worker-Demo
dotnet test Calculator/SciCalc.slnx
dotnet test UrlShortener/UrlShortener.slnx

The Calculator domain/test solution needs no MAUI workloads. The full app solution requires them; see the SciCalc project guide.

Use your own judgment and your own AI coding agent. The deep dive includes a balanced inspection prompt and evaluation method. Choose your acceptance criteria first and judge the result, remaining cleanup, and hands-on time. Your existing AI-agent costs may apply.

Try a task on our demo board — by email or Trello

Show how

Join the public demo board, or email your Trello username to request access, usually addressed within 24 hours. Create a bounded task in To Implement, or draft it in Triage and move it when ready. Watch DigitalWorker deliver a tested PR to the public demo repository.

To add your own cards to the demo board, use a free Trello account. No GitHub credentials or LLM key are needed. Use a public-safe task on this shared board — no special card format, write it like any task. Want privacy instead? Start on your own repo below with a private board.

Prefer to try it by email? Send us a task you can share publicly — we’ll post the card for you and send you the link to follow the resulting PR.

Start using it on your repo — Trello + GitHub

Show how

Use the included $15 credit to evaluate one bounded real task on your own codebase before paying. Larger tasks should be scoped first; the credit does not guarantee every task costs $15 or less. Further usage is prepaid: contact us for a secure payment link when you want to add credit. Work pauses when your balance runs out.

1. Email your preferred Trello board name. The first 20 early adopters get personal setup help from the founder, including a private board, usually within 24 hours.
2. On the private board, follow the 2-question onboarding steps: install the DigitalWorker Agent GitHub App on your repository from its public install link (~1 minute), then answer the 2 onboarding questions on the first card — repository HTTPS clone URL and default branch. No tokens to create or paste. Setup does not run an AI coding task.
3. Add a bounded task and acceptance criteria in To Implement, or draft in Triage and move it when ready.
4. Review pivotal decisions as needed, receive the tested/reviewed PR and design package, and perform the final behavior check. Use experienced architecture review for complex or novel design decisions.

Or start even smaller: ask DigitalWorker to review a slice of your codebase. It marks architecture and code-smell issues as //TODO comments — without touching your code. Count how much it finds. The issues it surfaces are the same disorganization that makes AI-written code plateau and eat your attention.

You need a Trello account, GitHub account, and a repository you can authorize. We provide the AI infrastructure. No local install, terminal, or per-developer setup is required for this path.

The full agent currently takes tasks from Trello. GitHub Issues integration is coming soon.

Screenshots that demonstrate real life use cases working on a real prod repo

---

Agile Design LLC · New York, NY

Message on LinkedIn · Email us · agiledigitalworker.com · User Guide

© 2026 Agile Design LLC. DigitalWorker and its workflow materials are proprietary.

1. “Production-ready” means the implementation has completed the engineering process and is ready for your final hands-on check. Founder-observed results are not an independent benchmark or a defect-free guarantee for every codebase. ↩ ↩²

2. These benefits describe the full DigitalWorker Agent. The Reviewer reviews existing pull requests; it does not implement changes. ↩

3. The strongest controlled evidence brackets the gain narrowly: three field RCTs across 4,867 developers at Microsoft, Accenture, and a Fortune 100 company found a 26% increase in completed tasks with an AI assistant (Cui et al., Management Science, 2025) — while a 2025 METR RCT found experienced open-source developers were actually ~19% slower with AI tools on their own mature repositories, even though they believed they had been ~20% faster. Our founder’s own measured experience before adopting AI-checklist-driven workflows matched the ~25% figure. ↩ ↩²

4. Evidence from OpenClaw (2026): maintainers had to halt feature work for 7 weeks and then integrate 16,000 PRs in one release, stating that human review, architecture and release processes had become the bottleneck; ~80% of AI-generated PRs get rejected; of what passes, more than half of subsequent commits are fixes for what was just merged; new releases routinely regress working functionality, forcing users to pin old versions; the project’s own engineers publicly acknowledged AI “vibe slop” slips through because review capacity cannot scale with agent output. Asking AI to fight its own slop shifts the bottleneck from writing code to reviewing it rather than eliminating it. ↩

5. Tornhill & Borg, Code Red: The Business Impact of Code Quality (IEEE/ACM TechDebt 2022) — peer-reviewed analysis of 39 proprietary production codebases (30,737 files): low-quality code contained 15× more defects, took 124% more development time to resolve issues, and showed 9× longer maximum cycle times. Independently, Stripe’s Developer Coefficient survey (2018) found developers spend ~42% of the work week on technical debt and bad code. In founder experience AI-generated code falls under the same math: trained on average human code, it reproduces average professional quality at best, so the codebase-scale penalties apply unchanged. ↩

6. Founder-observed expectation based on 20 years of development experience and production use — not an independently benchmarked ranking. ↩ ↩² ↩³ ↩⁴

This site is open source. Improve this page.