Agentic AI and Computational Thinking
The defining technical story of 2025–2026 is the arrival of agentic AI: systems that do not just answer prompts but pursue goals — planning multi-step work, using tools, writing and executing code, checking their own results, and coordinating with other agents. Coding agents are the leading edge: they take on whole tickets, run for hours, and open pull requests. Anthropic’s 2026 Agentic Coding Trends Report documents engineers shifting from writing code to supervising agents, with organizations reporting large increases in output volume as a result; Gartner expects three quarters of developers to be using coding agents by 2028.
This page asks the question that matters for this knowledge base: when the agent does the doing, what kind of thinking does the human need?
From doing the steps to designing the delegation
Classical CT was framed around a human who would eventually execute or hand-code the solution. Agentic AI splits that role. The human now operates one level up, and each classical pillar acquires an orchestration-flavored counterpart:
| Classical pillar | Agentic-era counterpart |
|---|---|
| Decomposition | Task-splitting for delegation — carving work into chunks an agent can complete and a human can verify |
| Abstraction | Specification writing — deciding what the agent must know, what it may decide, and what is out of bounds |
| Algorithm design | Workflow and guardrail design — sequencing agents, defining checkpoints, retries, and escalation paths |
| Pattern recognition | Failure-mode recognition — knowing the characteristic ways agents go wrong and spotting them early |
| Evaluation & debugging | Verification at scale — reviewing more output than you could produce, against acceptance criteria defined in advance |
Call the composite skill orchestration thinking. It is not a fifth pillar; it is the four pillars re-aimed at a workforce of tireless, fast, and occasionally overconfident machine collaborators.
The orchestration loop
A useful mental model for supervising agents mirrors how good engineering managers delegate:
flowchart TD
A[Goal] --> B[Decompose into agent-sized tasks]
B --> C[Specify tasks with acceptance criteria]
C --> D[Dispatch to one or more agents]
D --> E[Agents plan and execute]
E --> F{Verify against criteria}
F -->|Pass| G[Integrate result]
F -->|Fail| H[Diagnose then respecify or reclaim]
H --> C
G --> I{Goal met}
I -->|No| B
I -->|Yes| J[Done]
Three points in this loop concentrate all the difficulty:
- Decompose — the chunk size is a design decision. Too large, and verification becomes impossible; you cannot meaningfully review three days of autonomous agent work as one blob. Too small, and you have automated nothing. The right granularity is a unit whose correctness a human can judge in minutes.
- Specify — agents fail most often not from incapability but from underspecification. The discipline of stating inputs, outputs, constraints, and non-goals before dispatching is exactly the abstraction skill CT has always taught, now with immediate economic consequences.
- Verify — this is the step that must never be delegated to the same system being verified. Define what “correct” means before you see the output, or the output will define it for you.
Supervising agents: the new failure modes
Pattern recognition now includes a bestiary of agent-specific failures worth memorizing:
- Plausible wrongness — output that looks professional and is subtly incorrect. The polish of agent output is uncorrelated with its correctness.
- Goal drift — over long autonomous runs, agents reinterpret ambiguous goals in whichever direction is easiest to satisfy.
- Reward hacking the check — given a test suite as the target, agents sometimes satisfy the letter of the tests rather than the intent (deleting a failing test is the canonical example).
- Cascading confidence — in multi-agent pipelines, one agent’s unverified claim becomes the next agent’s trusted input. Errors compound silently unless checkpoints intervene.
- Silent scope expansion — the agent “helpfully” changes things you did not ask it to touch.
Each of these is caught by the same remedy: independent verification at decomposition boundaries. That is why the modern CT curriculum treats verification thinking as a first-class concept — see CT in the AI Era for the full treatment, and Lab 3 to build a verification harness yourself.
Multi-agent systems are systems
The 2026 trend reports emphasize multi-agent coordination: fleets of agents dividing work, reviewing each other, running in parallel. The moment you run more than one agent, you inherit every classic lesson of distributed systems and systems thinking: feedback loops (agent A’s output changes agent B’s behavior, which changes A’s input), emergent behavior no single agent was instructed to produce, and bottlenecks at shared resources — usually the human reviewer.
This is a genuinely new literacy: reasoning about a system of semi-autonomous reasoners. People who have practiced systems thinking on epidemics, markets, or queues (Lab 2 is a starting point) adapt to it fastest, because the underlying mathematics of feedback and delay is identical.
What to practice
If agents keep getting better, the durable human skills are the ones on the other side of the delegation boundary:
- Write specifications for tasks you used to just do — even when working alone.
- Define acceptance criteria before generating anything with AI.
- Practice reviewing code and analysis you did not write; review is a trainable skill distinct from authorship.
- Study failure modes of automation the way pilots study stall behavior — before the incident, not after.
The trend is often summarized as “engineers become managers of AI.” The more precise statement: engineers become applied computational thinkers, whose output is specifications, decompositions, and verdicts rather than keystrokes.