Know Thine Enemy (Ko)

Amy J. Ko is a professor at the University of Washington Information School and a longtime LLM skeptic. In July 2026 she published the results of a deliberate experiment: three months paying for a Claude Max subscription and API credits, moving her open-source development onto Claude Code (Opus 4.8, later Fable) to test the marketing promise — could she get more done, or get her weekends back, and what would it cost the people around her. The title states her method: study the tool you argue against, because you can't argue against it credibly without understanding what people see in it.

Ko is careful to say she is a best-case user, not a novice. She has programmed since she was 12, writes meticulous design specs before any code, and maintains real projects, including the 300K-line Wordplay. The report is an expert's.

What worked, and the 10% that didn't

With clean architecture and rich context, Claude Code produced a reasonable implementation about 90% of the time. Those cases still needed repair — it ignored repository conventions that were documented and everywhere, and it re-implemented existing functionality as code clones unless told not to — but the problems were mostly minor comprehensibility and maintainability issues.

The other 10% were abysmal. Because the model couldn't hold the whole repository, the defects were deeply embedded assumptions: algorithms with performance problems only visible if you knew how the app was used, quality assumptions about usability and accessibility carried over from generic internet code, test cases that encoded faulty requirements and so overstated correctness. A few times it clobbered data and deleted uncommitted edits unrecoverably. She caught any of it only by reviewing every generated line and pushing back through many rounds of feedback. The work felt less like building and more like a game of telephone — describe something, get a distorted version back, iterate until it's shippable but not coherent or beautiful. Her comparison: like any capitalist economy, it settles for commodity because commodity is cheaper and faster.

Time back, attention gone

Claude did free some time — all-day Saturday sessions shrank to mornings. But the mornings became fragmented instead of focused. The workflow divides attention by design: monitor the planning so it doesn't skip context, read the plan, grant permission for risky operations every few seconds to minutes, then review unfamiliar code rather than code you wrote and already understand. Net faster than doing it herself, but it converted a couple of hours of flow into thirty minutes of distraction spread across chores and email. Running several sessions in parallel made it worse — interruptions every minute. This is the same friction-removal that dont-outsource-learning and cognitive-debt describe from the comprehension side: the friction that got sanded off is where the focus lived.

She also names a compulsion to keep going, sharpened by Anthropic's phone remote-control feature, which let the distraction follow her anywhere — into meals with her wife, into her reading, writing, and student advising. The only thing that curbed it was money: subscription session limits and API costs. She calls that relationship extractive — respect the limits and you're well, want more making and it costs more money, less focus, less joy.

It warped the design process

Ko has a Ph.D. in HCI, and her instinct is to pause and ask whether, why, and for whom something should be built before building it. Claude Code assumes a different premise: an individual decides. Nothing in the product supports collective or stakeholder-driven design; GitHub and version control are expert spaces, not collective ones. The path of least resistance is to isolate — talking to people only slows you down when you have tokens to burn. Because shipping feels a prompt away, the tool creates the illusion that the right design can come later, when shipping actually means racing to assume. Her countermeasures — mandating elaborate "why" articulation in pull requests, methodically interrogating the assumptions built into an implementation, restricting Claude to implementation far downstream of design — all require discipline the technology actively discourages.

The moral conclusion

Ko ends where the engineering-skeptics usually don't. She grants the narrow computer-science achievement: automated program synthesis was a dream a decade ago and is now real, the largest leap toward automating software development the field has made. But she reads the whole thing through the political economy it sits in, citing her colleague Emily Bender on the broader costs and Audre Lorde's line that the master's tools will never dismantle the master's house. Her landing is harm reduction — she'll use Claude Code when it's a survival strategy inside a system indifferent to her survival, under no illusion it's a tool for liberation.

The calculus shifts for others. For students she worries about learning avoidance and the self-regulation required, given how much expertise her own experiment showed these tools demand to use well — the same expertise-dependency skill-atrophy-supervision-paradox names. For non-programmers vibe-coding a personal tool, the harm may be smaller because it centers one person's requirements, but a world of fragile software is a poor foundation for commerce and work.

Where it sits

This is the reconciliation slot of the anti-llm-discourse cluster, the harm-reduction variant. Like llm-critics-are-right-use-anyway (Theocharis), Ko accepts the critics' case in full and keeps using the tools under heavy discipline. The difference is the exit: Theocharis frames LLMs as amplifiers of skill you already have; Ko frames continued use as survival rather than endorsement, and carries a stronger political-economy argument underneath. Her craft observations line up with no-silver-bullet-llms — the hard 10% is embedded assumptions the model can't see — and her refusal of the neutral-professional register echoes i-will-never-use-ai, except Manning-Franklin refuses the tools outright where Ko keeps using them.

Interesting from the discussion

The Lobsters thread focused less on Ko's politics than on the permission-interruption problem she describes. Simon Willison drew the line sharply: agents in YOLO mode (approve nothing) are a genuinely different tool from the default ask-for-permission mode, which is much of why people report wildly different experiences, and why he prefers running them in a throwaway container. A reply pushed back on manual approval as security — when a command is harmless 99.999% of the time you build a reflex of clicking Approve before your brain finishes reading it, which one commenter called "Vista-level security theater," with a Tesla-autopilot analogy for the ergonomics. Another walked through the Claude Code for Web docs and flagged the footguns (a cloud session reaching any repo the connected GitHub account can see, secrets visible to anyone who can edit the environment, comment-triggered CI that Claude can fire on your behalf). A follow-up then corrected part of it: in practice a web session is scoped to the repo you start it against, GitHub calls go through a proxy that limits pushes to a dedicated branch, and cloning another private repo now triggers a fresh permission prompt.

Cross-references

• amy-ko-blog — the author; Bits and Behavior on Medium
• llm-critics-are-right-use-anyway — the sibling reconciliation piece; amplifier framing vs Ko's survival framing
• dont-outsource-learning, cognitive-debt — the attention and comprehension cost Ko describes from the flow side
• no-silver-bullet-llms — the embedded-assumption failure in the hard 10%
• skill-atrophy-supervision-paradox — the expertise these tools demand to use safely is exactly what's at risk
• i-will-never-use-ai — the outright-refusal neighbor; same diagnosis, opposite decision