Dan Luu built an AI agent to write a 6,000-word post in hours

The process uses a supervised 'agentic loop' that turns a high-level goal into executed code. It signals a shift from writing code to managing autonomous systems.

Dan Luu, a software engineer known for detailed systems analysis, produced a 6,000-word blog post on AI-assisted coding in a few hours. The process, which he reports would normally take days or weeks, was executed by a custom AI agent he supervised. The post itself is the primary artifact of the workflow.

This workflow is not about conversational prompting. It is a structured, multi-step agentic loop where a large language model generates and executes a plan of shell commands to achieve a high-level objective, with the human operator acting as a manager.

The one-shot agentic loop

Luu’s process centers on a script that gives a large language model with a 1M token context window access to a shell. The core instruction is a single, high-level goal: "Write a post on AI coding." The model is responsible for creating a step-by-step plan, writing the necessary code and commands to execute it, and then parsing the results to inform its next action.

This is a departure from typical chat-based AI assistance. Instead of a series of prompts from the human, the agent runs autonomously until it completes a task or requires intervention. The human does not feed the agent snippets; the agent requests feedback or approval on its self-generated plan.

From high-level goal to executed code

The agent began by outlining a plan. This included steps like finding data on AI’s impact on coding productivity, analyzing that data, generating plots, and writing prose to connect the findings. To execute this, the agent generated its own shell commands.

For example, it used curl to download data sets and wrote Python scripts using matplotlib to generate charts. Each output, whether a data file or an error message, was fed back into the model's context window. This allowed the agent to perform self-correction, such as debugging its own Python script when it failed to run. The entire interaction history, including commands and their outputs, remains in context.

Supervising the agent, not writing the code

The operator’s role shifts from writing code to reviewing, debugging, and steering the agent’s plan. Luu’s role was not to write code or prose, but to oversee the agent’s process. He reviewed the initial plan, approved steps, and provided high-level feedback when the agent got stuck.

This "human-in-the-loop" supervision is critical. The agent is not fully autonomous and can make logical errors or get caught in repetitive loops. The value is in offloading the rote mechanics of execution, freeing up the operator to focus on strategic direction and quality control.

What we'd change

The playbook's primary dependency is the operator's own deep technical expertise. Luu’s ability to build the agent script, diagnose its failures, and guide it effectively is a prerequisite not explicitly included in the "few hours" timeframe. A founder without a strong engineering background would find this system difficult to replicate.

The efficiency claim also elides the setup cost. While the post-generation took hours, the development of the underlying agentic framework likely took significantly longer. This is a prototype of a new workflow, not an off-the-shelf tool. The focus is on the execution speed once the system is built.

Furthermore, the process requires access to frontier models with very large context windows, which are not yet commoditized or universally accessible. The cost of running a 1M-token-context model for several hours could be substantial, placing it outside the budget of many bootstrapped projects. The playbook is a preview of what becomes possible as model access and cost improve.

Landing

Luu's experiment is less a specific, replicable tactic and more a signal of a fundamental shift in technical work. The role of the skilled developer begins to migrate from pure implementation to system management. The core competency becomes defining a goal with sufficient clarity that an AI agent can decompose and execute it. This redefines technical leverage from writing better code to building and directing better autonomous systems.

The investor read

This workflow signals a move from prompt engineering to 'system engineering' for AI. The defensible moat is not the model, but the stateful, self-correcting loop built around it. Investable opportunities lie in startups that can productize these complex agentic workflows for specific verticals, abstracting away the high technical skill Luu's method currently requires. While this is a solo developer's prototype, it's a direct view into the architecture that VC-backed platforms like Devin are attempting to build for the enterprise. The key risk is the pace of model commoditization; a platform's value must be in the workflow, not just access to a large context window.

Pull quote: “The operator’s role shifts from writing code to reviewing, debugging, and steering the agent’s plan.”