Code from Nowhere: What AI Agents Really Take from Programmers

For the past two years, the most common question people asked about AI coding tools was simple: Can it write code? Is it fast? Can it fix bugs?

Those questions still matter, but they miss the bigger shift. The latest generation of AI tools no longer just answers questions. It enters development environments, reads files, modifies code, runs tests, observes results, and adjusts. Software development is moving from “humans write code, AI suggests improvements” to “AI participates in the workflow, humans own the outcome.”

Code arrives faster than ever. But a harder question is emerging alongside it: when code starts appearing as if from nowhere, do we still understand the systems we maintain?

From chat assistant to environment actor#

Anthropologist and web developer Heikki Wilenius recently published an essay called Code from Nowhere on Allegra Lab that offers a clear lens on this shift. He runs an independent academic WordPress site and has experienced two very different modes of AI-assisted development.

The first mode was chat-based: paste a code snippet to a model, get explanations and suggestions, then decide what to copy, modify, and test yourself. At this stage, AI feels like a talking search engine. It saves research time, but remains fundamentally advisory.

The second mode is agent-based: the model doesn’t just reply in text — it enters the development environment, inspects files, modifies code, runs commands, and evaluates results. The human still gives instructions, but many intermediate operations are automated. Wilenius describes it as letting the model “get inside the computer.”

This is a significant change. AI is no longer producing potentially useful text. It is acting within real systems, adjusting based on file structure, runtime feedback, and error signals. It has moved from “telling you” to “showing you.”

Faster code, not faster understanding#

For indie developers, small teams, and tool builders, this transformation is seductive. Problems that used to take half a day to debug can now produce a working fix in ten minutes. Old codebases that felt too risky to touch can be handed to AI for reading, analysis, and modification.

But there is a catch: code generation speed does not equal understanding speed.

Wilenius describes a case involving a profile image loading issue. The AI agent found what seemed like a reasonable cause in the local environment and fixed part of the problem. But the test server and production server were not identical. Weeks later, the issue returned. Only after repeated rounds of human-agent collaboration did the real causes emerge: differences in server infrastructure, avatar service limits, and production environment nuances.

This reveals something important about real-world development. The hardest part is rarely writing the code. It is understanding the code’s environment. A feature’s stability depends on local machines, test servers, production servers, third-party services, caching, permissions, and network requests — a web of factors no AI can fully grasp on the first pass.

When humans passively accept AI-generated outputs without providing context, checking assumptions, or verifying impact, “efficiency gains” become “accelerated technical debt.”

From author to responsible person#

What makes Code from Nowhere valuable is that it does not frame AI agents as simple replacements for programmers. Instead, it uses an anthropological lens to examine how roles are shifting within software work.

Traditionally, a programmer occupied three roles simultaneously: they set the intention, wrote the code, executed the changes, and bore responsibility for the result. The goal-setter, author, executor, and accountable person were the same individual.

In an agent-driven workflow, these roles split apart. Humans set the goal. AI generates and modifies code. The toolchain runs tests. The server environment determines outcomes. But final responsibility still rests with the human.

This creates an uncomfortable truth: AI may be the direct “writer” of the code, but when something breaks, the person using the AI is still accountable.

This means programmers in the AI era are not freed from understanding. On the contrary, they need to be clearer than ever about: what the task goal is, where the system boundaries lie, what assumptions the AI is making, which results require human verification, and who is responsible when things go wrong.

The programmer is shifting from “code author” to “system responsible person.” The truly valuable capabilities are expanding from writing code to describing tasks, providing context, designing verification workflows, assessing risk, and maintaining systems.

Code from nowhere is not from nowhere#

The phrase “Code from nowhere” captures something interesting. It does not mean code has no origin. It means the origin has been obscured.

When AI generates a code snippet, the user sees an instant, fluent, clever-looking result. But behind that result is a vast network of open source code, forum discussions, developer experience, documentation, tutorials, and community collaboration. Knowledge that was scattered across the internet, built by countless contributors over years, is repackaged as a magical capability: you ask, it delivers.

For the user, the code seems to appear from nowhere. For the open source ecosystem, it is the product of long-accumulated public labor.

This raises a deeper question: if AI absorbs large amounts of open source knowledge and re-packages it as a commercial capability, will the maintenance burden on open source communities increase? If more AI-generated code flows into projects, who reviews it? Who cleans it up? Who maintains it long-term?

The open source community is already expressing concern about AI-generated low-quality issues, pull requests, and security reports consuming maintainers’ time. AI can both help maintain open source and create new maintenance burdens. The question is not whether to use AI, but whether to place it within a responsible workflow.

The same shift applies to all knowledge work#

Although Code from Nowhere focuses on software development, its insights apply broadly.

In writing, AI can generate a first draft, but humans still need to judge whether the argument holds, the sources are reliable, and the expression is appropriate. In financial work, AI can organize receipts and spreadsheets, but humans must assess risk, compliance, and accuracy. In government work, AI can summarize policies and generate checklists, but accountability, judgment, and implementation oversight remain human.

The more AI can “generate,” the more human value shifts toward “judgment.”

Previously, the bottleneck in many jobs was starting from zero: writing code, writing reports, writing documents. Now AI can produce a first draft quickly. The new bottleneck becomes: is this draft reliable? Does it fit the context? What has it missed? Does it introduce risk? Can it be maintained long-term?

This is why being good with AI is not just about asking good questions. It is about designing workflows: knowing when to let AI draft, when to let AI check, when human review is mandatory, and when results should be turned into repeatable processes.

Five habits for indie developers#

For indie developers, AI agents offer immediate value: read old projects, generate pages, fix bugs, add tests, write documentation, preview deployments. One person can indeed do more.

But the smaller the team, the more dangerous it is to pursue speed alone. Small teams lack dedicated testing, operations, and security staff. If code becomes unmaintainable, the long-term cost is much higher.

Here are five habits for using AI agents responsibly:

1. Give full context. Don’t say “fix this.” Describe the project structure, runtime environment, target behavior, and what should not break.
2. Ask for explanation before modification. Let the AI explain its diagnosis, proposed changes, and impact scope before it touches code.
3. Every change must be reversible. Git commits, backups, or staging environments — always leave room to roll back.
4. Ask for tests and documentation alongside implementation. Don’t just make it work. Make the next maintenance easier.
5. Turn successful workflows into SOPs. Once a flow like “read invoice → identify amount → validate month → generate table → flag anomalies” stabilizes, reuse it consistently.

Mature AI use is not asking a one-off question every time. It is integrating AI into a repeatable workflow.

Not everyone will code, but everyone must understand systems#

A common prediction is that AI agents will let everyone write software. There is some truth to this, but it is incomplete.

More accurately, AI will let more people generate software, modify software, and automate workflows. But whether software runs reliably over time still depends on whether someone understands the system.

A non-programmer might use AI to build a small tool. But if they do not understand where data comes from, how permissions work, how errors are handled, how users interact with the system, and who fixes it when it breaks, that tool is likely a temporary toy.

AI lowers the barrier to starting. It does not eliminate the requirement to take responsibility.

This is the central message of Code from Nowhere: as code becomes easier to generate, humans must not give up understanding. What determines a system’s value is not that it runs once. It is whether the system can be explained, repaired, updated, and trusted in a real production environment.

AI will not replace you, but it will enlarge your responsibility#

AI coding tools are moving us into a new phase. We used to treat AI as an assistant that answers questions and offers suggestions. Now it acts like a colleague that enters the environment, executes tasks, and modifies systems.

This brings genuine efficiency gains and gives individuals and small teams more creative power. But it also makes responsibility more complex: who wrote the code? Who understands it? Who maintains it? Who answers for mistakes?

Perhaps the scarcest skill in the AI era is not the ability to make AI write code. It is the ability to judge whether the AI wrote it correctly.

When code begins to appear from nowhere, the real task is not to marvel at the magic. It is to ask: where did it come from, what does it depend on, what did it change, and who will take care of it.

The future may have much more AI-written code. But what keeps systems running reliably will still be human understanding, judgment, and responsibility.