Level 0 is the first rung of the six-level agentic-engineering ladder: chat-based AI with no file access.
A human pastes code or context into ChatGPT Enterprise, Claude for Work, Gemini for Workspace, Microsoft 365 Copilot, GitHub Copilot Chat, or a JetBrains AI sidebar. The human reads the response.
The human pastes the answer back into the IDE by hand. The model itself does not touch the repository. It does not run the code. It does not see the test output. Every step that is not a paste is done by a person. IDEs can sometimes bridge the gap and pick up the chat response and update files or provide inline editing tools. But importantly, the model’s output modality is text, it doesn’t touch your environment.
This is the level most enterprises are at. It is also the level with the least defensible upside. On real enterprise work the productivity range sits somewhere between 19% slower and 22% faster. The tools you are already licensing support the deeper, controlled-access workflows where the real gains live, so sitting at L0 means using them in their weakest mode.
For context on the other levels above, see my post about The Levels of Agentic Engineering.
The Level 0 Workflow
Four moving parts:
- A human working on a task, normal process.
- The human invokes the model, types/pastes into chat window with a question.
- The model responds with text.
- The human edits and pastes the answer back into the IDE (or the IDE provides some avenue to stream line this).
Between step four and the next step one, the model has no memory, no view of the codebase (other than what your IDE automatically passes in), no way to verify its own output. Every turn is a cold start on context. Simon Willison’s definition is load-bearing: “Code execution is the defining capability that makes agentic engineering possible.” L0 chat does not execute. The human is the runtime, the integration layer, and the test harness all at once.
The Productivity Improvement:
Three numbers circulate in the market. You need to know what each one actually measured, so you can choose which one to put in your board paper.
The lab number: 55.8%. GitHub’s own 2022 RCT (Peng et al.) placed 95 Upwork developers on a greenfield JavaScript HTTP-server task. The Copilot group finished 55.8% faster, with a 95% confidence interval of 21% to 89%. The task was single-file, solo, throwaway. Task-completion rate did not change, only speed. This is the number the CIO deck always quotes. It is also the number no enterprise has ever measurably replicated on production code using just Conversational AI Assistant chat.
The field number: 8–22%. The follow-up, Microsoft and Accenture in late 2022 measured pull requests per week across 1,974 developers on real internal work. Microsoft: 12.9–21.8% more PRs per week. Accenture: 7.5–8.7%. That is the range you can defend upwards. Anchor here, not on 55.8%. The more senior and enterprise-y the team, the closer the number lands to the Accenture end.
The inconvenient number: −19%. METR’s July 2025 RCT is the study most ignored. 16 experienced open-source maintainers. 246 real issues on codebases they had worked on for an average of five years, averaging over one million lines of code and 22,000 GitHub stars.
Developers forecast a 24% speed-up.
Afterwards they believed they had been 20% faster.
The actual measurement: 19% slower.
The summary for your board paper: At Level 0, on real enterprise workloads, expect team-level throughput change between 19% slower and 22% faster, with stability and senior-developer velocity at risk if we do not measure both sides.
A note on METR’s study. Even in early 2025 Cursor’s Composer and Agent Mode were in beta. While they were rudimentary it does mean that this study includes some more advanced AI usage also (beyond Level 0).
Governance at Level 0
Four controls specific to paste-based workflows. None of them are controversial. Most of them are not built.
Data-Exit policies (what gets pasted in and where). Defined policy around what can egress. Decide whether code, production logs, or production data can egress.
Data-Exit Controls. These should enforce the above policy. Usually this takes the form of DLP or CASB, enforcing the types of data and destinations outlined in the policies.
Output-Acceptance Controls (what comes back). Slopsquatting means the paste-back is now a supply-chain vector for attack. Code review, PR review, and build-time package verification need to treat AI-suggested imports as untrusted by default. Luckily most teams already have a robust process for reviewing code. This just becomes more important.
Simple Regulatory Alignment. Examine your sovereignty rules and retention rules for vendors, then pick a tool (and deployment model) that fits. Most foundation models can be served through Inference-as-a-Service (AWS Bedrock, Azure AI Foundry, GCP Vertex) and support most Zero Data Retention needs.
The controls at Level 0 are largely behavioural. They depend on many individual employee decisions on:
- What tools to use
- What context to share with a model
- How to use the output received
Don’t stay at Level 0
Level 0 is a bad place for an enterprise to land long-term. The productivity savings are meagre. The governance posture is the hardest of any level on the ladder, because it depends on millions of individual paste-in decisions rather than programmable controls. The 39-point gap between felt and measured productivity is wide enough to mislead you and your leadership team for a year before anyone measures the drop.
A handful of workloads genuinely fit chat-only and don’t need to move:
- Explaining stack traces, unfamiliar code, and dense policy documents.
- Translating between frames: policy into FAQ, spec into board brief.
- Rubber-ducking, learning a new framework, writing a regex from plain English.
- Knowledge-worker drafting where the human is the domain expert and AI is the typing.
For everything else, and especially for any team where engineering throughput is the metric, the next step is Level 1: the model gets controlled, governed access to your environment (the file system, the test runner, the CLI), and the human stops being the integration layer.