laranevans.com
Topics / Agentic Development

Agentic Development

pillar/systems pillar/self topic/agents topic/development

Agentic development is the practice of building software with autonomous LLM-driven tools as collaborators rather than autocomplete. The work shifts from typing each character to specifying intent, reviewing generated diffs, and steering longer-running tasks. The IDE is no longer the only surface. A terminal session with Claude Code, a side-panel chat in Cursor, or an asynchronous Codex task all count.

The shift is significant enough to deserve its own vocabulary. "AI-assisted coding" describes a spectrum running from inline completion through delegate-and-review. The agentic end of that spectrum behaves differently: the tool runs a loop, invokes its own tools, navigates a codebase without per-step prompting, and returns with a diff. The skills required to use it well overlap less with classic IDE skills than they do with code review, technical writing, and delegation.

What changes

A few practitioner observations worth carrying:

  • Specification matters more than typing speed. The bottleneck shifts from key-presses to clarity. A vague request to a capable agent produces plausible-looking but wrong code. A precise request produces code worth reviewing. This is the prompt engineering question moved into the development loop.
  • Review skill compounds. An agent producing ten diffs an hour creates a review backlog faster than one producing one. Practitioners who keep up are the ones who read diffs quickly and accurately. Those who do not become bottlenecks on their own agents.
  • Codebase context becomes a first-class artifact. A CLAUDE.md, AGENTS.md, or equivalent instruction file is now part of how the project compiles in practice. The instructions inside shape every agentic interaction, the way a Makefile shapes every build. See Context Engineering.
  • Test discipline matters more, not less. An agent landing a change cannot tell you whether the change broke an invariant the test suite does not cover. The cost of an under-tested codebase rises when the rate of change does.

What does not change

The practice does not eliminate the engineer's responsibility. The agent's diff lands under the engineer's name in the commit log. The reviewer's job (whether human or another agent) does not go away. Architecture decisions, trade-offs, and system design all remain on the engineer's side of the line.

Some practitioners describe this as "the agent does the typing, the engineer does the thinking." The framing undersells the typing. Modern agents do navigation, search, refactoring across files, and test-running in addition to typing. The division of responsibility still holds. The engineer is the architect, the reviewer, and the integrator. The agent is everything in between.

Atomic pages

  • Agentic Workflows — the patterns that compose LLMs with tools and control flow.
  • Agentic Systems — the production deployment surface: observability, cost, safety, reliability.
  • Reasoning and Acting — the ReAct pattern (Yao et al. 2022): interleaved Thought, Action, Observation steps. Filename unfurled to avoid collision with React JavaScript.

More atomic pages land as the cluster grows. Sub-pages for Claude Code, Codex, and Cursor are in progress.