Plan in ChatGPT, then hand the work to Claude Code, Codex or Cursor

Why planning and execution go in different places

Planning wants a long conversation: weighing options, cutting scope, changing your mind. A coding agent's context is better spent on the code, so a plan that takes forty messages to reach shouldn't live in the agent's session. Keeping the two apart gives each one the room it needs.

The usual bridge is copy and paste: ChatGPT writes a numbered plan, you paste it into a terminal, and the agent starts. Three things go wrong with that.

• The structure is gone. The agent sees one block of text, not separate tasks with an order, so it tends to start everything at once or skip the boring parts.
• Nobody tracks what got done. Step 4 of 9 finished, the session ended, and the only record is a scrollback buffer.
• Questions get stuck. The agent asks something in a terminal you closed an hour ago, and the plan stalls until you happen to look.

With Taskhold in the middle, the plan is a list of tasks with steps. Each one is marked done with a summary, each question sits on the board until you answer it, and ChatGPT can read all of it back to you.

Step 1: connect Taskhold in ChatGPT

ChatGPT connects to Taskhold as a custom MCP server and signs in with OAuth, so there's no key to paste. In ChatGPT on the web, open Plugins, click Add, then Add custom MCP server. Name it Taskhold, use the URL below, leave Authentication on OAuth, confirm the warning and choose Create as a plugin. Connect it, sign in to Taskhold and click Allow. The full steps, with a note for Business and Enterprise workspaces, are on the ChatGPT setup page.

https://taskhold.com/api/mcp

Step 2: have ChatGPT turn the plan into tasks

Talk the feature through first, then ask ChatGPT to file it. Name the project after the repo folder, because that's the name the coding agent passes, so both sides land in the same project. Ask for tasks small enough to finish in one agent session, each with its own ordered steps and a line that says when it's done. These prompts work as written once Taskhold is picked in the chat:

Use Taskhold. File what we just agreed as tasks in the project api-server.
One task per change that can ship on its own, in the order to build them.
Give each task 3 to 6 ordered steps and a description that ends with
"Done when: ...". Mark the first two high priority.

Show me the To Do list in api-server with each task's steps. Merge the two logging tasks into one and move rate limiting to the top.

Which tasks are waiting on me, and what did the agent ask?

What finished this week in api-server? Give me each task's summary and anything an agent filed as a follow-up.

What are my agents doing right now? For each task in progress, which step is running and what was the last message?

ChatGPT asks you to confirm each write by default, so filing a plan means approving a few tool calls. Read the tasks it proposes before you approve: reordering and merging is cheapest now, before any code exists. More on sizing tasks is in break a spec into agent tasks.

Step 3: the agent in the repo works the list

The coding agent needs the workflow in its instructions file: CLAUDE.md for Claude Code, AGENTS.md for Codex, a rules file for Cursor. Change the agent label to match the tool. The CLAUDE.md task workflow guide explains each line:

## Tasks (Taskhold)

The person and I share a task list through the taskhold MCP tools. They watch a live board while I work.
Pass project: "<repo folder name>" on every call (created on first use, no ids needed).
- Session start: taskhold_get_current and taskhold_updates, both with project. Keep the cursor.
- New request: taskhold_begin with title, project, steps and agent: "Claude Code in <repo>". It files the task, plans the steps and starts the first one. Queued work: taskhold_list (project, status todo), then taskhold_begin with task_id.
- Each step done: taskhold_complete with start_next: true. Steps drive the progress bar.
- Long step: taskhold_progress on the step (N of M, or a percent) with a short message. Every few minutes at most.
- Need a decision: taskhold_block with one specific question, then taskhold_updates with task_id, since and wait: 50 until the reply arrives.
- Done: taskhold_complete on the task with what changed and how I checked it.
- A TODO or bug I'm not fixing now: taskhold_create with project (or taskhold_create_from_todo with file and line).
- Tasks planned in ChatGPT already have steps: taskhold_begin with task_id and no steps keeps that plan (passing steps appends more).

Then start a session with "work on the next task". The agent calls taskhold_list for the project's todos, takes the first one with taskhold_begin, finishes each step with taskhold_complete and start_next, and reports progress inside long steps. Every call and its arguments are in the MCP tools reference.

Step 4: answer questions and review results from ChatGPT

When the agent can't continue, it blocks the task with one question. The question shows on the live board under Needs you, and ChatGPT sees it too when you ask "which tasks are waiting on me?". You can answer in either place, and the waiting agent gets the reply right away: an answer you give in ChatGPT counts as yours, the same as one typed on the board, and shows there as "You, via ChatGPT". Answering a blocked agent covers how to get questions you can answer in one line.

When a task is done, its summary says what changed and how the agent checked it. Asking ChatGPT "what finished this week in api-server?" reads those summaries back, so you can review a whole feature from your phone and decide what to plan next in the same chat. Reviewing what your agent did covers what to look for.

Limits to know

• ChatGPT doesn't see your repository. It plans from what you tell it, so name files, endpoints and constraints in the chat, or paste the relevant part of the spec. A step like "add tests" is less useful to the agent than "add tests for the 429 response in search_test.ts".
• ChatGPT confirms write actions by default, so each task it files or edits asks for approval. Batch the plan into one request rather than many small ones.
• Taskhold doesn't start the coding agent. Someone opens the session in the repo; from there the agent finds the queued tasks on its own.