All pages

Agentic development foundations · Lesson 1.1 · 10 min · Free

Agentic development is delegation

What the agent does, what stays your job, and where TRMNLY fits.

Listen

After this lesson you can say what an agent does well, which parts of the work stay yours no matter how good the agent gets, and how TRMNLY puts the agent next to the terminal so you can hand work off and still see every step.

Time: 10 minutes · Works on: macOS app.

You stop typing and start delegating

When an agent writes most of the code, your job changes shape. You spend less time typing and more time on the parts around the typing: deciding what should exist, explaining it, checking what came back, and deciding whether it ships.

That is delegation, the same skill you use when you hand a task to a colleague. A good colleague can read the code, run the tests and try things. They can't read your mind. They don't know which shortcut you'd never accept, which file is fragile, or what "done" means for this change unless you tell them. An agent is the same, with two differences that matter. It works much faster, so a vague request turns into a lot of confident, wrong work very quickly. And it starts every session knowing nothing about you beyond what's written down.

So the habits that make agentic development work are delegation habits:

  • Say what you want, not how to type it. Describe the outcome and the limits. Let the agent find the files.
  • Say how you'll know it worked. A test that passes, a page that renders, a command whose output changes. If you can't say it, the agent can't check it.
  • Keep the task small enough to review. You'll read every change. A change you can't read in a few minutes is a change you'll wave through.
  • Write down what keeps being true. Conventions, commands and decisions go somewhere the next session can find them.

The rest of this course takes each of these in turn.

What stays your job

Four things don't move to the agent, however capable it is.

Intent. Only you know why the change exists and what it's for. The agent can propose options. It can't decide that the feature is worth building or that a trade-off is acceptable to your users.

Judgment. The agent will tell you its change works. Sometimes it's right. You decide whether the approach fits the codebase, whether the risk is worth it, and whether a failing test is a real failure or a broken test.

Review. You read the diff. Not a summary of the diff. An agent's summary of its own work is the least reliable thing it produces, because it describes what it meant to do.

Merge. You decide what lands on the branch other people build on. In TRMNLY this is also the default everywhere: the agent asks before it writes, and a fleet of agents opens pull requests for you to merge rather than merging on its own.

Everything else is open to delegation: finding the right files, reading logs, writing the code, writing tests, running them, fixing what they catch, and writing the commit message.

Size the work

The most common early mistake is handing over a task that is the wrong size. Too big, and the agent makes many decisions you never see. Too small, and you spend more time briefing than you'd spend doing it.

Compare two requests for the same goal.

Improve the error handling in the API.

That asks the agent to decide what "improve" means, which errors matter, and how far to go. You'll get a large diff touching many files, and no clear way to tell whether it's right.

In src/api/orders.ts, the createOrder handler returns a 500 with a stack trace when the request body is missing customerId. Make it return a 400 with {"error": "customerId is required"}. Don't change other handlers. Add a test in tests/api/orders.test.ts for the missing field, and run npm test -- orders until it passes.

That one has a goal, a limit, and a way to check. The agent can finish it without asking you anything, and you can review the result in two minutes. A good rule of thumb: if you can't describe how you'd check the result, the task isn't ready to hand over yet. Split it, or write a spec first.

Where TRMNLY fits

Most agent tools sit in a separate window and see only the files you point them at. TRMNLY puts the agent in the right sidebar of the terminal you already work in. That changes three things.

  • The agent sees what you see. It can read your terminal panes, run commands where you can watch them, and drive the built-in browser. When a test fails in a pane, you can say "fix that" and it knows what "that" is.
  • Every step is visible and gated. Each action is a tool call shown as a card in the transcript. With the default posture, actions that change anything wait for your approval, and every call lands in an audit log.
  • The surrounding workflow is built in. Worktrees give each agent its own checkout. The Kanban board holds the work as cards agents can claim. The Review tab lets you leave notes on the diff and send them back as the next task.

You can also bring your own agent. Claude Code, Codex and Gemini CLI run in a pane like any program, or stand in as the sidebar agent's model, and they can call TRMNLY's tools over MCP.

Do it in TRMNLY

Delegate one small, checkable task and keep the four human jobs for yourself. You need a model connected (Connect a model) and a project that is a git repository.

  1. Select the project on the left sidebar's rail and open a tab in it.
  2. Press ⇧⌘\ to show the right sidebar and choose Agent.
  3. Check the header. The posture chip should read Approve, so write tools wait for you. The working-directory chip should name your project's folder.
  4. Pick a real, small task you already understand, and write it with a goal, a limit and a check, like the createOrder example above. Send it with Return. Use ⇧↩ for new lines.
  5. Watch the tool cards. Read-only calls such as reading files run on their own. When a card asks to write a file or run a command, read the diff or the command line before you press Approve. Press Deny on anything you wouldn't have done yourself, and see the agent adjust.
  6. When the agent says it's done, don't take its word for it. Open More ▾ → Review in the right sidebar and read the diff yourself.
  7. If something is off, click the line, write a note, and press Send to agent. Your notes go back as one message.
  8. When you're satisfied, commit it yourself. The merge decision is yours.

Check yourself

  • You can name the four jobs that stay yours: intent, judgment, review and merge.
  • Your task said how its result would be checked, and the agent ran that check.
  • You denied at least one tool call, or can say why you didn't need to.
  • You read the diff in the Review tab rather than relying on the agent's summary.

Go further