Three Role Shifts for Engineers in the AI Agent Era: From Coders to System Designers

When Agents Start Handling Long-Running Tasks

At a recent aiDotEngineer conference, renowned developer @steipete raised a thought-provoking point: as AI Agents grow increasingly capable of handling long-running tasks, the center of gravity in software engineering is fundamentally shifting. Engineers are no longer the ones personally typing every line of code — they are evolving into direction-setters, output reviewers, and system designers.

About aiDotEngineer and @steipete

aiDotEngineer is a developer conference focused on AI engineering practices, bringing together frontline AI application developers and framework builders — making it a key window into the cutting edge of AI engineering. Peter Steinberger (@steipete) is a well-known iOS developer and open-source contributor who founded PSPDFKit (now rebranded as Nutrient), and has in recent years become an active voice in AI engineering. His perspective commands wide attention because it combines hands-on engineering experience with a product mindset — he's not discussing AI in a lab, but continuously working with Agent systems in real product development, which lends his observations unique credibility.

This shift sounds simple, but it carries profound implications for how software development is practiced. For decades, an engineer's core value lay in translating requirements into working code. Now that models can autonomously handle the entire pipeline from planning to implementation, the coordinates of human value are being redefined.

From Writing Code to Setting Direction

Direction Determines Outcomes

In traditional development workflows, engineers are often buried in implementation details: how to optimize a loop, how to design class inheritance, how to handle edge cases. When AI Agents can take over these tasks, engineers must shift their attention to a higher level — clearly defining what problem needs to be solved, and why it should be solved this way.

Setting direction demands stronger product thinking and system abstraction skills. You need to clearly communicate to the Agent what the goal is, what the constraints are, and how priorities are ordered. A vague direction will lead even the most powerful Agent to the wrong destination. In other words, the quality of prompts and goal-setting directly determines the ceiling of what an Agent can produce.

The Technical Depth of Prompt Engineering

Prompt engineering is far more than "asking a good question." In Agent scenarios, the System Prompt needs to precisely define the Agent's role boundaries, tool-use specifications, output format constraints, and error-reporting mechanisms. High-quality prompt design borrows from Formal Specification thinking — using clearly defined preconditions, postconditions, and invariants to constrain Agent behavior. Additionally, the design of Chain-of-Thought prompting and Few-shot examples directly affects model accuracy on complex reasoning tasks. Research shows that professional prompt design can improve Agent task completion rates on complex tasks by 30–50%, which is the technical basis for the claim that "prompt and goal-setting quality determines the ceiling of Agent output."

New Challenges Brought by Long-Running Tasks

@steipete specifically emphasized "longer-running work" as a key premise. Early AI coding assistants operated primarily on immediate responses — you ask a question, it gives an answer. New-generation Agents, by contrast, can work continuously for minutes or even hours, autonomously decomposing tasks, calling tools, and iteratively correcting their work.

This capability leap has clear technical underpinnings. Modern Agent frameworks (such as LangChain, AutoGPT, and Claude's Computer Use) use the ReAct (Reasoning + Acting) paradigm to enable models to continuously observe their environment, reason about the next step, and take action during execution — forming a closed loop. Proposed by Google Research in 2022, ReAct's core innovation is interleaving a language model's reasoning process with external tool calls within the same generation stream. At each step, the model first "Thinks" (Thought), then "Acts" (Action), and feeds the result back as a new "Observation" for the next round of reasoning. This design significantly reduces model hallucination rates and gives Agents the ability to self-correct in complex tasks.

Another key technical breakthrough enabling long-running tasks is the standardization and maturation of tool-calling interfaces (Function Calling / Tool Use). The native tool-calling APIs introduced by Anthropic and OpenAI in 2023 allow models to reliably invoke external environments — such as code interpreters, browsers, and file systems — in a structured manner, dramatically lowering the engineering complexity of bridging "reasoning" and "action." This standardized interface is what truly enabled Agents to evolve from "being able to talk about how to use tools" to "reliably using tools to get work done," forming the foundational infrastructure for long-horizon autonomous execution.

Long-running tasks also rely on persistent context management. Yet even for large models supporting 200K tokens, the accumulated execution history from hours of continuous operation can rapidly fill the context window. Industry approaches include: sliding-window summarization (compressing history into structured summaries to retain key information), external vector database retrieval (fetching relevant historical snippets on demand), and hierarchical task decomposition (breaking long tasks into independent subtasks, each with its own context). These architectural choices directly affect the Agent's directional consistency and error accumulation rate over long executions, enabling operation across the limits of a single conversation.

Multi-Agent Orchestration: Another Dimension of Long-Running Tasks

Beyond single-Agent persistent execution, long-horizon complex tasks increasingly adopt Multi-Agent Orchestration architectures: an "Orchestrator" Agent handles task decomposition and progress coordination, while multiple "Worker" Agents process subtasks in parallel and report results back for integration and verification. This architecture is analogous to microservices design in software engineering — separating concerns and parallelizing work to significantly improve overall throughput. OpenAI's Swarm framework, Anthropic's recommended Multi-Agent patterns, and tools like LangGraph are all engineering implementations of this orchestration approach. Multi-Agent architectures also introduce new complexities: inter-Agent communication protocol design, state consistency guarantees, and error propagation isolation become new system-level design challenges.

This capability leap immediately raises a new question: how do you ensure an Agent stays on course throughout a long execution? This is precisely why "setting direction" has become such a critical responsibility.

From Execution to Reviewing Output

The second shift is reviewing work. As Agents continuously produce large volumes of code and solutions, an engineer's core task changes from "producing" to "gatekeeping."

This is actually a higher-cognitive-intensity mode of work. Notably, a 2023 Microsoft Research study found that developers exhibit significant "Automation Bias" when reviewing AI-generated code — a tendency to reduce the intensity of critical scrutiny applied to AI output.

The Cognitive Science Roots of Automation Bias

Automation Bias was systematically articulated by aviation psychology researchers including Lisanne Bainbridge in the 1990s, originally used to describe how pilots over-relying on autopilot experienced degraded judgment. Its core neurological mechanism: when humans perceive a system as authoritative or highly reliable, active monitoring engagement in the prefrontal cortex decreases, and cognitive mode shifts from "analytical mode" to "confirmation mode." In AI code review scenarios, this effect is amplified by the Fluency Heuristic: AI-generated code tends to be well-formatted, thoroughly commented, and consistently named — visually more "professional" than a human draft. The brain mistakenly maps this surface fluency to a signal of "content correctness," further lowering the threshold for critical scrutiny. This means that in AI code review, relying solely on traditional code review intuition is far from sufficient — engineers need to deliberately cultivate meta-cognitive recognition skills tuned to "AI-specific failure modes" (e.g., hallucinated API calls, logic that appears correct but is semantically wrong, concealed security vulnerabilities).

At the same time, AI-generated code often hides subtle semantic errors or security vulnerabilities beneath a veneer of surface-level correctness — such as unsafe deserialization or race conditions. This means reviewing Agent output requires not only quickly comprehending code you never wrote yourself and judging its correctness, efficiency, and risks, but also deliberately training meta-cognitive capabilities to recognize "model-specific failure modes" — not just relying on traditional code review instincts.

In some ways, this resembles a senior engineer reviewing a junior engineer's code — except that "junior engineer" is an AI that never tires and produces at breathtaking scale. The efficiency and accuracy of reviews therefore become the new bottleneck for a team's overall productivity.

From Coding to System Design

Designing Better Systems Around Models

The third — and most strategically significant — shift is "designing better systems around the models."

This phrase reveals a deeper truth: relying solely on a model's inherent capabilities is not enough. What truly determines how well an AI Agent works is often the "scaffolding" surrounding it — including tool-chain design, context management, feedback loop construction, and error recovery mechanisms.

The Technical Meaning of Scaffolding

In AI engineering contexts, Scaffolding refers to the entire supporting infrastructure built around a core language model. It includes: the tool-calling layer (giving models access to external APIs, databases, and code execution environments), memory and context management (short-term working memory and long-term vector retrieval), error handling and retry mechanisms, and multi-Agent coordination protocols (such as OpenAI's Swarm or Anthropic's Multi-Agent framework). Research shows that the same base model can achieve task completion rates that differ by several times depending on Scaffolding design. Accordingly, Scaffolding design capability has become one of the most competitively differentiated core skills for AI engineers.

Retrieval-Augmented Generation (RAG) architecture is one of the key components of modern Scaffolding. RAG was formally introduced by Meta AI Research in 2020 in the paper Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks, originally designed for static knowledge Q&A scenarios. In Agent engineering applications, RAG has evolved into a dynamic, multi-source, hierarchical retrieval system: before the model generates a response, semantically relevant document fragments are retrieved from external vector databases and injected into the context — used not only for knowledge Q&A, but also to provide real-time codebase context, historical execution records, API documentation, and business rules. Advanced RAG architectures (such as HyDE and Self-RAG) further introduce hypothetical document generation and self-reflection mechanisms, significantly improving the precision and quality of information the Agent retrieves — making it one of the most representative engineering practices for "designing better systems around models."

Superb engineers need to think: How do you provide Agents with the right tools? How do you organize information so models can understand it more easily? How do you design validation mechanisms to catch errors? This system-level design work is at the core of AI Engineering — an emerging discipline in its own right.

AI Engineering as an Emerging Discipline

AI Engineering is distinct from traditional ML Engineering — the latter focuses on model training, hyperparameter tuning, and deployment, while the former is more concerned with integrating existing Foundation Models into real products and workflows. The core topics of AI Engineering include: prompt engineering and system prompt design, Retrieval-Augmented Generation (RAG) architecture, Agent orchestration and workflow automation, and building model evaluation systems (Evals). It's worth highlighting that Evals fill a critical engineering gap: traditional software engineering deals with deterministic systems where the same input always produces the same output, verifiable through unit tests. AI Engineering, by contrast, deals with probabilistic systems whose failure modes are unstructured and difficult for traditional testing frameworks to cover. Evals address this by building benchmark test suites and using methods such as LLM-as-Judge to provide statistical quality assurance for Agent behavior. Stanford's 2024 AI Index Report notes that AI Engineering-related job demand has grown over 200% in the past two years, making it the fastest-growing specialization in software engineering.

The Collaboration Architecture Between Humans and Agents

Designing systems around models is, at its core, building a new type of human-machine collaboration architecture. In this architecture, Agents handle the heavy lifting of execution, while humans are responsible for high-level decision-making, quality assurance, and continuous optimization. Direction-setting, output review, and system design — together, these three form the core capability matrix of the future engineer.

Human-in-the-Loop Architectural Design Principles

The "human-Agent collaboration architecture" corresponds in engineering practice to an important design pattern: Human-in-the-Loop (HITL). HITL is not simply "having humans supervise AI" — it involves carefully designing, at the system architecture level, when and at what granularity humans should intervene: which decision nodes require human confirmation, which steps can be executed fully autonomously, and what types of anomalies should escalate to human review. Over-intervention cancels out the efficiency gains of Agents; under-intervention introduces uncontrollable risk. Good HITL design requires dynamically calibrating the intensity of human involvement based on a task's risk level, reversibility, and uncertainty — which is itself a system design task requiring deep engineering judgment.

Implications for Engineer Upskilling

This trend places clear upskilling demands on every practitioner:

• Abstraction ability matters more than coding speed, because you need to set clear direction;
• Judgment matters more than memorization, because you need to quickly review massive volumes of output while resisting the distortion of "automation bias";
• Systems thinking matters more than local optimization, because you need to build better operating environments for models.

To be clear, this does not mean foundational technical skills become irrelevant. Quite the opposite — only a solid technical foundation can support effective direction-setting and output review. You need to understand the ReAct paradigm to design reasonable Agent behavioral boundaries; you need to understand context management to evaluate Scaffolding architecture quality; you need to understand probabilistic system failure modes to build effective Evals frameworks. What changes is how skills are applied, not the value of the skills themselves.

Closing Thoughts

@steipete's observations at aiDotEngineer were brief, but they precisely captured the direction of software engineering's evolution in the AI era. As AI Agents gradually take over long-running execution work, engineers' value will not disappear — it will migrate upward. From writers of code, engineers will grow into designers, directors, and guardians of intelligent systems.

For every engineer living through this transformation, actively embracing these three role shifts may be the key to maintaining core competitiveness in the age of AI.