14 fast-growing startups hit 10x output with Claude Code. Anthropic distilled it into five rules: everyone ships, automate the boring stuff, trust then verify, assume code will be rewritten, and prototype to internal use before launch. The most counter-intuitive one: letting lawyers and doctors submit PRs too. It redraws the line of "who counts as an engineer."
Lawyers and doctors submit code themselves; CEOs tweak the UI too
"Everyone ships": the people closest to the problem submit the first fix, as long as Claude can see the tools they use every day.
Parahelp co-founder Mads Lunau Liechti is a non-technical CEO(the highest-ranking person in a company) who also ships UI (user interface) changes himself. Anthropic's finding: engineering output is rising, while non-technical output has emerged from zero—and the latter carries domain expertise(hands-on experience accumulated over years in a specific industry) that engineers don't have.
Crosby has pushed this further. Co-founder and CEO Ryan Daniels says Claude Code has changed "what it means to be a lawyer at Crosby": lawyers are themselves the product's power users, and coding tools turn their product instincts directly into shippable changes—that is, PRs(Pull Request, a request to submit changes to a code repository).
Heidi has flattened the chain even more. Co-founder and CEO Dr. Thomas Kelly calls the old layered handoff "the telephone game": a new idea goes from proposer → product manager → designer → engineer—four hands—and by launch time it's barely recognizable, taking weeks; now the person who understands the problem submits the PR directly, pulling in designers and engineers only when their judgment is needed.
Clay's hiring bar has shifted too: they specifically look for "tinkerers"—candidates willing to push an idea all the way to a working version themselves, not stuck in docs and meetings. The group spans vertical players like Crosby, Harvey, and Heidi (legal, medical) as well as infrastructure and engineering-productivity companies like ClickHouse, Omni, Cognition, and Commure.
Why "code completion" isn't enough: carving out the work nobody wants
Four companies each cited a different number, but they all point to the same thing: Claude Code isn't "helping engineers write a few more lines"—it carves out entire chunks of triage, test runs, and merges, the "tedious but essential" work.
What's different from earlier AI coding tools? Those stayed in the IDE helping with completions. Claude Code connects the MCP (Model Context Protocol—an open interface letting AI read/write external tools and databases) pipeline directly to the team's existing GitHub, databases, and internal systems.
People no longer need to copy-paste context to the AI—the AI pulls data itself, writes code, and writes it back. Without this bridge, none of those four numbers would materialize.
Clay, Artemis Security, Omni, and ClickHouse each reported a figure, and the common thread is: the machine took over the "must-do but nobody-wants-to" portion. The three cards below break down the specifics behind those four numbers.
An honest caveat: all four numbers above come from Anthropic's own long-form piece citing customer self-reports. No independent third-party verification has surfaced. Treat them as "what customers say," not "objective scorecards."
Where does the saved headcount go? ClickHouse's extra features aren't the same features delivered in greater volume—they're newly opened up by people freed from "chores." Automation fills the organizational vacuum of "nobody wants to own this." Once that vacuum is filled, the bottleneck across the product development cycle shifts from "who can code" to "who has the good ideas."
After delegation, who catches the fall?
Letting non-engineers submit PRs—the real challenge isn't "anyone can change code," it's "what makes this code trustworthy enough to ship." These companies' answer: review is the safety net, not the gate.
Heidi's "telephone game" described above is fundamentally about message distortion—and Claude Code cuts out the middle links.
Sounds like letting the wolves run the henhouse. But three phrases Anthropic's interviews kept returning to are the real story: automated testing, PR review, and tiered permissions. Guardrails aren't removed—they're repackaged.
Artemis Security's extreme weekly throughput and Clay's automated triage are both extensions of the same logic: people review code quality; machines review whether code runs, who changed it, and what it touched.
Anthropic didn't disclose how each company configures CI/CD(automated code testing + deployment pipeline), but kept stressing "lightweight but traceable"—review must exist, but can't become a bottleneck blocking engineers and non-engineers from collaborating.
This division of labor has a side effect: the engineer's job gets reshaped. Once lawyers, support, and designers can edit the front end directly, the engineer's core value shifts from "writing code" to "building pipelines"—setting up test frameworks, defining permission policies, writing PR review rules. Heidi's framing is "pull them in where their expertise is needed." Non-engineers are expanding outward; engineers are pulling the foundation inward.
Code is a consumable, not an asset
The fifth rule is the most counter-intuitive of the five: code written today should be assumed throwaway in a few months. Models iterate every few weeks, requirements shift daily, and patch-style fixes(patching old code just to keep it running) often cost more than a full rewrite.
Anthropic's logic is straightforward: underlying models leap in capability every few months, and old prompts, old API calls, old code structures all depreciate. A carefully polished function might be three lines in the next generation. Patching legacy code is essentially gluing engineering effort onto scaffolding destined for obsolescence.
This rewrites a decade of mainstream software engineering narrative. Less change, careful refactoring, pursuing long-term maintainability—that's the standard answer in engineer promotion reviews. Claude Code pushes the opposite script: treat code as a consumable.
Prototype, ship, run for a few months, see if the model upgraded, and rewrite if it did. Anthropic codified this cadence into the rule "Build for rebuilding."
Team prioritization shifts accordingly. Clay's bug routing and Artemis Security's PR volume mean the codebase's "half-life" is being artificially shortened. Investing time in reading new code is now more worthwhile than maintaining old code. New-hire onboarding's center of gravity moves from "understanding historical baggage" to "quickly discarding historical baggage."
How to tell if this rule is actually landing? Watch over the next 3 to 6 months whether these startups start publishing "rewrite rate" metrics—for example, how many lines of code are replaced wholesale each quarter rather than patched line by line. On the flip side, if engineering blogs start complaining about "regressions from rewrites" or "context loss" rising, it means "write-to-rewrite" has hit the ceiling of engineering discipline, and the rule will be quietly watered down.
Read first, then decide: wait for a team account
The source doesn't offer a full hands-on guide for non-engineers—it's more founders talking about process and culture. The actionable move right now is to notice something that may already be happening around you.
The original report's five principles are for 14 startups, not an out-of-box guide for individual users. It doesn't lay out "download, install, first run" steps—it keeps circling one idea: let people who've never written code submit PRs—requests to push changes to the codebase for others to review. Crosby's co-founder put it plainly: lawyers are now the people with the most say in the product, because they are the users.
The first thing an ordinary reader can do is ask their own team: who is closest to the problem but blocked from the code? Heidi's founder Kelly described the old way as "someone has an idea, throws it to the PM, the PM throws it to the designer, the designer throws it to the engineer—by launch, the idea's been ground down." If that sounds familiar at your company, the next step is worth taking.
The next step isn't actually "jump into Claude Code"—it's watching for official releases. The original report is on Anthropic's blog, and at the end they mention a PDF summarizing the five rules and a checklist, with the download link right in the article, titled "The Claude Code guide for startups." Whether individuals can use it, how to pay, what the path is—the source doesn't say. Don't guess; wait for the official word.
The only takeaway that really matters: when a company starts letting lawyers, doctors, and support staff submit PRs, the line of "who counts as an engineer" needs redrawing. The tool isn't the point—redrawing that line is.
Open Anthropic's original blog post, find the section "checklist at the end of this guide," and bookmark the link.
Find someone at your company who "knows the user best but can't code," and list the last time they wanted to change the product but were blocked.
Watch Anthropic's official Claude Code individual-plan updates—whether you can sign up, whether it requires a subscription, how to form a team. The original source doesn't say, so don't trust secondhand reports.
Forward Crosby and Heidi's stories to your boss: lawyers submitting PRs, frontline doctors bypassing PM to change the product—then ask, "what about us?"
Source: Claude official blog (Anthropic, published August 20, 2026). Disclosure: All data and principles in this article come from the vendor's first-hand interviews with customers, compiled and published by Anthropic. Quoted according to each startup founder's original words.