Agentic engineering: build with AI agents and stay on top of the work

What is agentic engineering?

A coding agent is more than a chat that suggests code snippets. It works directly in your project folder: it reads files, searches the code, runs tests, changes several files, and checks the result itself. Agentic coding describes what the agent does. Agentic engineering describes the discipline around it: how you write briefs, make results verifiable, and keep the responsibility.

The term has a well-known godfather. In February 2025, Andrej Karpathy, a co-founder of OpenAI, coined “vibe coding” for a way of programming where you fully give in to the vibes and forget that the code even exists. Collins named it its Word of the Year for 2025. A year later, in February 2026, Karpathy called “agentic engineering” his preferred term for the professional version: agentic, because most of the time you no longer write the code yourself but direct and supervise agents; engineering, because there is skill and experience in it.

Agentic engineering vs. vibe coding: the difference

Both use the same tools. The difference lies in how much you define up front and how thoroughly you check afterward.

Vibe coding isn’t a mistake; it’s a tool for the right moment. Many vibe coders switch to engineering the moment the experiment turns into something other people use.

You direct: brief, review, decision

With agentic engineering, your work shifts. You type less code and do three things more thoroughly:

• Brief: You describe what should be built and how to tell when it’s done. The more precise the brief, the fewer rounds of corrections.
• Review: You read the diff, look at the test results, and try the result. An agent stops when the work looks done; only a review shows whether it is.
• Decision: Merge or rework, next task or change of course. These decisions stay with you.

Typical friction when you work with coding agents every day

If you work with agents daily, you know these spots:

• Open items disappear in the chat history. At the end of a session, three things are left over. A few days later, they’re buried under new messages or closed along with the session.
• Tasks for you hide in long answers. The agent needs an API key, a DNS record, or an approval in the App Store and mentions it in the fourth paragraph of its summary.
• Several sessions, several projects. One window runs the course page, a second a bug fix, a third some research. Only you know which state lives where.
• Full context windows. Long sessions make agents worse, which is why Anthropic recommends starting fresh with /clear between unrelated tasks. Anything that isn’t in a file is then gone for the agent.

The remedies have one thing in common: the state of the work belongs in files, not in the chat.

In practice: Claude Code workflows that hold up

Tasks as files instead of chat history

Create every task as a file the agent can read and change: with a title, status, owner, and a log. Then every new session starts with “Work through your open tasks,” and the agent finds everything it needs, even after /clear or in a different tool. At the end of a session, the brief is: “Create tasks for the open items.”

Specs with acceptance criteria

For anything bigger than a one-liner, you write a spec: goal, requirements, and acceptance criteria you can check off. In its Claude Code best practices, Anthropic advises letting the agent ask questions and write a spec first for larger features, then starting the implementation in a fresh session. Good specs name the files involved, say what is out of scope, and end with a check that shows everything works.

Set the level of autonomy: do, draft, ask

Not every task tolerates the same freedom. The agent may simply update a dependency. Copy for the home page it should prepare as a draft that you sign off on. For a database migration, it should ask first. Decide this per task, not once for everything.

Handbacks instead of summaries

When the agent is done, it shouldn’t just reply; it should hand the task back: for review, with a note on what it did and where the result is, or with a question if something is missing. Anything only you can do, it creates as a separate task for you.

Review with evidence

Ask for evidence instead of claims: the test output, the command it ran, a screenshot. Give the agent something it can check itself, such as tests or a build. For larger changes, Claude Code’s plan mode (Shift+Tab) helps: the agent reads and plans before it changes anything. And a second look in a fresh context, for example from a subagent, finds gaps the agent overlooks in its own code. It does code tasks in its own branch; you decide on the merge.

AGENTS.md and CLAUDE.md: the manual for your agent

Every session starts without any memory of the last one. What the agent needs to know about your project therefore goes into a file it reads at the start. AGENTS.md is an open format for this, a kind of README for agents, now stewarded by the Agentic AI Foundation under the Linux Foundation. Codex, Cursor, and many other tools read it. Claude Code reads CLAUDE.md and falls back to AGENTS.md when there is no CLAUDE.md; with @AGENTS.md, you include one in the other. Gemini CLI reads GEMINI.md; the file name can be changed.

# AGENTS.md

## Commands
- Tests: npm test
- Before finishing: npm run lint && npm run typecheck

## Rules
- Work in your own branch, never on main.
- No push and no deploy without approval.
- New dependencies only after asking.

## Tasks
Tasks live in TandemLoop, linked as ./tandemloop.
Read ./tandemloop/AGENTS.md first. Anything only I can do
(access, approvals, decisions), create there as a task for me.

Keep the file short. For CLAUDE.md, Anthropic recommends fewer than 200 lines and only what the agent can’t read from the code itself. If it repeats a mistake, the rule belongs in the file; if it has long been following a rule, you can take it out.

Tools: Claude Code, Codex, Cursor, Gemini CLI

Which tool you choose matters less than how you work. If instructions, specs, and tasks live in files, you can switch agents, and the new one picks up from the same state.

How TandemLoop supports agentic engineering

TandemLoop is a to-do app for Mac, iPad, and iPhone in which you and your agent share the same tasks. They live as text files in your iCloud Drive; your agent reads and writes them directly and follows a manual that TandemLoop provides. No plugin or API is needed.

Several agents and sessions read the same folder and see the same state. Only one should write at a time; otherwise, syncing through iCloud can create conflicting copies. The page A to-do app for working with AI agents shows the whole workflow; the guide Claude Code and Obsidian describes what the same setup looks like in an Obsidian vault.

Beyond the code, TandemLoop is a full to-do app with an Inbox, projects, due dates, and custom views. If you follow the GTD method, let the agent pre-sort the Inbox and prepare the weekly review.