I use Claude Code in two modes — YOLO for simple TODOs, interactive for bigger changes. I also have a review+fix skill for cleaning up the agent’s work. There’s a gap between the two though: I’ve done the hard part interactively and I just want the agent to wrap up.

The “Take Over” Skill

Here’s the skill:

---
name: take-over-finish
description: Take over and finish the coding task.
  Use when user says "take over" or
  "take over and finish for me"
---

Run the following with the right skills:

* review+fix

and if done build a TODO list of these and do:

* log task
* commit
* deploy
* submit URLs (if any frontend webpages have changed)
  to Google for indexing
* exit (skill)

Each of those tasks — review+fix, log task, commit, deploy, submit URLs, exit — is either a skill or something I’ve described in my AGENTS.md. I say “take over” and the agent runs through all of them in sequence without me.

When I Use This

I’m working interactively on something non-trivial. I’ve made the key decisions — the approach, how edge cases should be handled. The agent has done maybe 80-90% of the work. What’s left is straightforward — wiring things up, adding the remaining cases, running lint.

I say “take over” and switch to the next thing. Another project, another agent session, whatever. The agent has all the context from our conversation — it knows what I want because I’ve been telling it for the last 20 minutes. It just needs to finish.

This is how I multi-task with agents. I do the thinking for one task, hand it off, and start the next one.

Why Not Just Use YOLO Mode?

YOLO mode works when the task is simple enough to describe upfront in a TODO. For more complex work, I need to iterate — look at output, make decisions, adjust direction. That’s interactive mode.

But interactive mode means I’m there for the entire session. “Take over” lets me do the thinking, then move on. I don’t need to sit through the mechanical part.

How It Fits Together

YOLO mode is fully autonomous from the start. Interactive mode keeps me in the loop throughout. “Take over” starts interactive and ends autonomous — I do the thinking, the agent finishes on its own.

I chain it with review+fix too: “take over, review+fix, commit”. The agent finishes the work, reviews its own output with Codex, and commits when clean.