DEV Community

kohei matsunobu
kohei matsunobu

Posted on

AI Agents Are Shifting from Something You Build to Something You Delegate

Introduction

I'm a second-year student at ZEN University studying intelligent informatics, and I want to become an AI engineer. I build AI agents as personal projects.

The conversation around AI agents has shifted, at least in my daily work. For a while, the center of the discussion was how to build an agent. What I see now in ordinary development is how to delegate work to one. It feels as if we have moved from an era of agent development to an era of handing work to agents and letting them carry it out.

The skill that matters from here is not only the ability to build an agent. It is also the ability to design how work is delegated. In this article I gather what I think is needed when you hand work to an agent, drawing on two experiences: building an agent myself, and delegating implementation, tests, research, and documentation to Claude Code and Codex every day.

When the conversation was about building

Until recently, talk about AI agents was mostly about how to build them. Which model to use, how to wire tools, how to design RAG and memory. Those topics still matter.

I also built a personal AI agent, Yata, and experienced both the interest and the difficulty of making one. Yata is a personal assistant that runs on my own PC. You talk to it in Japanese in a chat, and it helps with research and with checking mail and calendars. While building it, I had to think not only about model choice, but also about how tools are connected, and about asking a person to confirm before any action that leaves the machine.

The code and write-ups are here:

What has changed in daily development

The way I develop day to day has been changing. I use Claude Code and Codex every day, and I hand much of the implementation, testing, research, and documentation to the agents.

My role has been moving from "the person who writes the code" toward "the person who decides what to hand over, and then checks the result." That does not mean I have stopped writing code. Writing and delegating-and-verifying now sit side by side in the same work.

Four things that matter when you delegate

These are the four things I find necessary in a time of delegation. They are not a special method. They are items that are less likely to go wrong if you decide them before you hand a task to Claude Code or Codex. I describe them as general practice. I will not invent numbers about how much faster any particular job became.

1. Splitting the task: write the goal and the done conditions first

If you only tell an agent to "handle it well," the scope often grows, or the agent starts "improving" things you did not ask for. Split the work into a size the agent can finish in one pass, and state the goal and the done conditions up front.

The way I try to write this looks like the following.

  • State the goal in one sentence. For example: "Add email and password validation to the login screen."
  • List the done conditions. For example: existing tests pass, new tests are added, files outside the requested area are not changed, the API shape does not change.
  • Also write what not to do. For example: do not redesign the UI, do not update dependencies.
  • Split requests that are too large. Instead of "make this feature better," use "add tests first," then "fix the implementation," then "update the docs."

When the done conditions are written down, the agent and I can judge "is this finished?" against the same bar. If you move on while that is still vague, you end up coming back later.

2. How you pass context: premises, constraints, and what not to touch

An agent may be able to read part of a repository, but it does not know the premises that live only in your head. If you do not say them first, it may rewrite code in a style you do not use, or edit files that should not be touched.

Information worth passing first includes:

  • Premises: what the project is, which language or framework it uses, and what is going wrong right now
  • Constraints: do not change the public API, match the style of this file, ask before adding a new dependency
  • What not to touch: .env and other secrets, production configuration, unrelated directories, generated files, and lockfiles that should not be rewritten without a reason

A simple approach with Claude Code or Codex is to say, explicitly, "Do not change the following paths." Write concrete paths for files that contain secrets, deploy configuration, and directories managed by someone else. It also helps to name the directories that may be changed, so the scope of the diff is easier to follow later.

You do not have to pass everything at once. The premises needed for that task, and the lines that must not be crossed, are often enough.

3. Verification: check the result with tests, review, and evaluation

After you delegate, you still need to check what came back. An agent may say the tests passed, but the tests may cover very little. I do not take the result as ready to merge without a review.

The points I look at are:

  • Tests: are there new tests, were existing tests run, and did the change hide a failure
  • Review: is there a diff outside the requested scope, an unasked-for refactor or new dependency, or a secret mixed into the change
  • Evaluation: are the done conditions met? If not, write what is missing into the next request

You can ask the agent to run the tests and report the result. I still read the diff myself, and I run things locally when I need to, rather than taking the report as final. Verification is not the opposite of delegation. It is part of delegating.

4. Permissions and safety: what may run automatically, and what needs a person

The more you let an agent into a repository or let it run commands, the more important the boundary becomes. If everything is manual, it is hard to delegate. If everything is automatic, operations you cannot undo may run.

One way to draw the line is:

  • Often fine to do automatically: reading code, running tests, producing a proposed diff, editing on a working branch
  • Needs a person's confirmation: a forced git overwrite, deleting files or branches, changing secrets or production configuration, deploying to production, publishing (a package or an article), and adding a new dependency with broad permissions

The important point is not to confuse what a tool can do with what it may do. If you keep history in git, you can still revert after trying a proposal. Operations that cannot be undone, that leave the machine, or that publish something, stay on the confirmation side.

When I built Yata, I used the same idea: wait for a person to confirm before actions that leave the machine, such as sending mail or creating a calendar event. The same thinking applies when you are the one delegating. The more you let an agent carry out work for you, the more you need to decide in advance where it must stop.

Experience building, and experience delegating

These four items can look like a discussion of process. I still feel that I can delegate more carefully because I have built the inside of an agent.

A model does not always follow instructions. Tools fail. Context runs short. If permissions are broad, unintended actions can run. Having seen that from the building side makes it easier to translate "where to stop," "what to say first," and "what counts as done" into the language of delegation.

I think both experiences — building and delegating — will be a strength for AI engineers. Not one or the other. If you can build, you can design how to delegate. If you try delegating, you can see what is worth building next. I am moving back and forth between the two.

Closing

I feel the center of gravity of AI agents is moving from something you build to something you delegate work to. That does not mean the building conversation is over. In everyday development, though, handing implementation, tests, research, and documentation to Claude Code or Codex is already a normal option.

The four things I try to get right when I delegate are splitting the task, passing context, verifying the result, and drawing the line on permissions and safety. They are less a clever trick than a plain habit: decide first, and write it down.

I study intelligent informatics at ZEN University, and I keep doing both: building AI myself, and handing development work to AI. I would be glad to exchange notes with others who are also trying out this way of working with agents.

Top comments (0)