The most effective path to automation is not building specialized agents for every business task, but collapsing those tasks into code for coding agents to solve. This provides a robust, 'engineering legible' foundation for automating knowledge work across an organization.
When an agent fixes a production issue, a human can instruct it via Slack to also update the core reliability documentation. This not only solves the immediate problem but durably encodes the process knowledge, turning ephemeral conversations into persistent, automated process improvements.
Building a visual debugging tool for trace files is wasted effort when an AI agent can directly analyze the raw data and provide the answer. Optimizing for human legibility in the debugging process is a mistake when the agent, not a human, is doing the fixing.
Instead of importing external libraries, AI agents can rewrite them from scratch. This 'in-housing' of dependencies strips away unnecessary generic features, focusing only on required functionality. This simplifies security reviews and patching, as the code becomes first-party.
In an agent-driven workflow, human review becomes the primary bottleneck. By moving reviews to after the merge, the team prioritizes agent throughput and treats human attention as a scarce resource for high-level guidance, not gatekeeping individual pull requests.
Instead of shipping compiled libraries, provide a detailed specification for an AI coding agent to read and implement locally. This emerging 'ghost library' model creates minimal, custom implementations, reducing bloat and making the code fully owned and modifiable by the local agent ecosystem.
To maximize leverage, reframe every SDLC component—docs, tests, review agents—as a way to 'prompt inject' non-functional requirements into the agent. This approach teases out expert knowledge from engineers' heads and makes it part of the automated system, guided by the agent's mistakes.
Instead of placing agents inside a pre-set environment, a more powerful approach for reasoning models is to start with just the agent. Then, give it the tools and skills to boot its own development stack as needed, granting it more autonomy and control over its workspace.
A custom '$land' skill delegates the entire post-push process to the agent. It autonomously handles waiting for reviews, fixing CI flakes, merging from upstream to resolve conflicts, and managing the merge queue. This automates the tedious 'last mile' of software delivery.
Initially, code-authoring agents blindly accepted all feedback from reviewer agents, leading to endless loops. The solution was to prompt the reviewer agent to bias towards merging and the author agent to defer or push back on non-critical feedback, mirroring human social protocols.
When a newer model version (GPT-5.3) became less patient with long-running tasks, the team was forced to re-architect their entire build system to complete in under a minute. This created a 'ratchet' that enforces performance discipline, preventing build time creep.
When AI agents handle all coding, the engineer's role elevates to high-level systems thinking. They no longer opine on individual PRs but instead infer patterns from the agent's work and provide architectural guidance, much like a tech lead for a very large organization.