In the Age of AI Agents, How Will Engineers' Work Change?

As coding-assist AI tools like Cursor and Claude Code penetrate development environments, the daily work of software engineers is undergoing transformation. Generating initial implementations of distributed streaming pipelines or complex APIs is no longer a primary bottleneck in development. AI agents can explore code repositories, write test code, examine error stack traces, and even suggest refactoring approaches. With friction in the task of "writing" code greatly reduced, the central question has become: "What remains for engineers?"

Understanding this shift benefits from concepts in thermodynamics. Just as a heat engine converts energy into useful work, an AI agent takes given instructions (prompts, requirements, tests) and transforms them into concrete outputs like code or configuration changes. However, like any engine, losses occur in agent loops too. Starting with a clear task, agents may drag along old assumptions, fix symptoms rather than root causes, and as context expands, subsequent steps become uncertain. This phenomenon—which might be called "operational entropy"—describes a state where loops move forward while old assumptions and unresolved dependencies accumulate.

What suppresses entropy is accurate feedback from outside. This includes human intervention, failing tests, strict data contracts, deterministic tools (mechanisms that return the same output for identical inputs), and evaluation systems that precisely communicate to agents "what went wrong." Without such signals, agents may continue generating outputs while drifting further from correct results. An agent "running" and an agent "doing useful work" are two different matters.

Given this situation, one can argue that engineers' roles are shifting from "people who write code" to "people who design system boundaries." Determining the scope within which agents can operate, maintaining integration points with external systems, and building mechanisms to detect and correct when agents go off track—such design decisions will become increasingly important. The ability to define how an entire system should behave, rather than writing code line by line, is becoming essential.

This direction aligns with the historical trajectory of software engineering. Each time abstraction advanced—from assembly language to C, then to higher-level languages—engineers were freed from low-level work and could tackle problems at higher levels of abstraction. The rise of AI agents can be seen as a continuation of this trend. However, it is important to note that as abstraction increases, the risk of poor judgment spreading across broader systems also rises.

Currently, AI agents are generally noted as struggling with areas such as clarifying ambiguous requirements, making decisions across organizational boundaries, and judging complex tradeoffs with legacy systems. All of these are situations requiring human contextual understanding and judgment. To avoid becoming a mere "rubber stamp" approving countless pull requests generated by agents, engineers themselves must continue to question what should be built, set boundaries, and evaluate results.

As AI agents are becoming established as development "implementers," the value of engineering is shifting from implementation speed to design quality and decision precision. The focus going forward will likely be on the ability to design how agents are controlled, evaluated, and operated within specific boundaries. Tools continue to evolve, but the capacity to question how they are used still remains on the human side.