From plain chat to integrated development

Plain ChatGPT chat and a repository-aware agent differ in access, not brand. A chat sees only what you paste into it, while Codex, Claude Code, and Cursor read the repository, run the tests, and return a diff they can check against your tests. Most paid ChatGPT plans include Codex, so you choose a surface, not a subscription.

You are chasing an intermittent 500 error. You paste the route handler into a chat, then the service, then the database setup, then the logs. Each answer is a plausible guess about code the model has never run, and you merge the fix by hand. This page is for developers and tech leads who still do real coding work through a chat window and want to know which tasks to move, how to move them, and how to check the result.

What you’ll walk away with from leaving copy-paste coding

• A table that tells you which tasks stay in chat and which go to an agent.
• A five-step routine for moving one task from a chat into Codex, Claude Code, or Cursor.
• Three prompts you can paste today: one for the chat, two for the agent.
• A way to accept the agent’s diff on evidence (tests, gates, scope) instead of reading every line.
• The five ways the switch goes wrong, and how to recover from each.

What changes when the agent can see the repository?

The same model can sit behind both surfaces. What changes is what the model can reach and what it can prove.

	Plain chat (ChatGPT, claude.ai)	Repository-aware agent (Codex, Claude Code, Cursor)
Context	What you paste or attach, nothing else	The repository: source, config, tests, and instruction files such as AGENTS.md or CLAUDE.md
Output	Text you copy and merge	Edits in your working tree, shown as a diff
Execution	None in your environment	Runs your test, build, and lint commands inside a sandbox or permission mode
Feedback loop	You run the code and paste the error back	The agent reads the failure and iterates until the command passes
Evidence	“This should work”	A test that failed before the change and passes after it
Persistence	The conversation, until it grows too long	Instruction files in the repo that every session reads

The last two rows are the reason to switch. A chat answer is a claim you verify yourself. An agent can hand you a claim plus the command output that supports it, and that output is what lets you stop reading every line.

Which surface fits which task?

Task	Plain chat	Agent	Why
Learn how OAuth2 refresh tokens work	Yes	—	No repository involved
Compare two architectures before you commit	Yes	Optional	A chat discussion is cheaper; an agent helps only when you want it to read the current code
Turn a vague request into acceptance criteria	Yes	Yes	Either works; the output feeds the agent task
Write a PR description from a diff you paste	Yes	Yes	Agents can read the diff themselves
Fix a bug that needs logs, code, and a test	—	Yes	The fix has to run to be trusted
Add a feature that touches more than one file	—	Yes	Manual merging is where copy-paste bugs come from
Refactor or upgrade a dependency	—	Yes	Needs the full test suite as the safety net

A useful rule: if you are about to paste a second file into a chat, the task belongs to an agent.

Is Codex a separate subscription from ChatGPT?

No. OpenAI’s Codex README (checked 2026-09-26) says Codex is included in the Plus, Pro, Business, Edu, and Enterprise plans. The same sign-in covers the Codex CLI, the IDE extension, Codex cloud tasks, and the desktop app (codex app, macOS and Windows). Neowin reported (secondary source) that on 2026-07-09 the Codex desktop app became a Codex mode inside the ChatGPT desktop app, and the Codex CLI on macOS now accepts either Codex.app or ChatGPT.app.

The other two tools have their own plans. Claude Code is included in Claude Pro, Max, Team, and Enterprise, but not in the Free plan. Cursor sells its own subscription. Allowances, usage windows, and prices change often, so compare them on the pricing and ROI comparison and check default models on the models hub rather than from memory.

How do you move one task from chat to an agent?

Keep the chat for the thinking and give the agent the doing. The order matters: criteria first, a read-only plan second, edits last.

1. Write acceptance criteria in the chat. Paste the request, the ticket, or the bug report, and ask for testable criteria (the first prompt below). You get a short list that the agent can be held to. See acceptance criteria an agent cannot misread for the full method.

2. Open the agent in the repository in a read-only mode. Start it at the repository root so it can read your instruction file, and ask for a plan before any edits.

   Codex

   # Terminal, at the repository root
   codex --sandbox read-only

   Type /plan in the session to get a plan first. When you approve it, exit and run codex resume --last --sandbox workspace-write so Codex keeps the approved plan in context and can edit files and run tests inside the workspace.

   Claude Code

   # Terminal, at the repository root
   claude --permission-mode plan

   Plan mode reads and proposes without editing. Approve the plan to let Claude Code start work; you can switch modes with Shift+Tab.

   Cursor

   Open the repository folder in Cursor, open the Agent, and switch it to Plan Mode. Cursor writes an implementation plan before it changes any code; approve it to let the agent build.

3. Paste the criteria with a test-first instruction. Use the second or third prompt below. The agent must show a failing test before it writes the fix.

4. Check the evidence, not the prose. Run the test, type, and lint commands yourself, and compare the files in the diff against the plan (the next section shows how).

5. Record what the agent had to ask. If the agent guessed a convention (the test runner, the error format, the folder layout), add it to AGENTS.md or CLAUDE.md so the next session does not guess. See how to write AGENTS.md for Codex and how to initialise a Claude Code project.

Copy-paste prompt for the chat: turn a request into acceptance criteria

I am going to hand this task to a coding agent that can read my repository
and run its tests. Turn the request below into acceptance criteria it cannot
misread.

Rules:
- Write each criterion as Given / When / Then, observable from outside the code
  (HTTP status, response body, database row, log line).
- Include at least two failure cases and one boundary case.
- List what is out of scope.
- List the questions you would need answered before starting. Do not guess the answers.
- Do not propose an implementation.

Request:
"Users get logged out every 15 minutes. Add refresh tokens to the Express API
so a session lasts 7 days, and revoke all tokens when the password changes."

Copy-paste prompt for the agent: debug an intermittent 500 test-first

The /api/orders endpoint returns intermittent 500 errors under concurrent load.

1. Read the route handler, the service it calls, and the database client setup.
   List the candidate causes (connection pool exhaustion, a race on shared state,
   an unhandled promise rejection, a missing transaction) with the file and line
   that makes each one possible.
2. Write a test that reproduces the most likely cause with concurrent requests.
   Run it and show me that it fails. Stop and ask me if you cannot make it fail.
3. Fix the cause with the smallest change. Do not edit or delete existing tests
   and do not add retries that hide the error.
4. Run the full test suite, the type check, and the linter.
5. Report: the root cause, the files you changed, the failing-then-passing test
   output, and anything you could not verify.

Copy-paste prompt for the agent: build a feature from acceptance criteria

Implement the acceptance criteria below in this repository.

Before you edit anything:
- Find how existing middleware, routes, and tests are written and follow those
  patterns. Name the files you used as examples.
- Give me a plan that lists every file you will create or change.

While you work:
- For each criterion, write the test first, run it, and confirm it fails.
- Then implement until it passes. Do not change a test to make it pass.
- Touch only the files in the plan. If you need another one, say why first.

When you finish, run the tests, the type check, and the linter, and report
each criterion with the name of the test that covers it.

Acceptance criteria:
<paste the criteria from the chat here>

How do you verify the agent’s diff without reading every line?

The agent’s summary is a claim. These four checks turn it into evidence you can accept in minutes.

1. Criterion to test. Every acceptance criterion names a test, and you saw that test fail before the change. A test that never failed proves nothing. See how to keep the agent from weakening your tests.
2. Your gates, run by you or by CI. Run the test, type-check, and lint commands yourself, or let CI run them on the pull request. Do not accept “all tests pass” from the agent’s summary alone.
3. Scope. Run git diff --stat and compare the file list with the plan. An unexpected file is the first thing to read.
4. A second reviewer on the risky lines. Ask a fresh session to review the change against the criteria. In Codex, codex review --uncommitted reviews staged, unstaged, and untracked changes. In Claude Code, run /code-review in a new session. In Cursor, open a new Agent chat and ask it to review the diff against the criteria. Read by hand only what the tests cannot cover: authentication, migrations, and security boundaries.

Who signs off stays the same as for human code: the person who opens the pull request owns it, and your normal review rules apply. The evidence bundle page shows how to attach this proof to the pull request so the reviewer checks evidence, not every line, and agent PR review covers the reviewer’s side.

When is plain chat still the right tool?

Chat stays the better surface whenever nothing in the repository has to change yet:

• Learning. You want an explanation of a concept at your level, with follow-up questions.
• Thinking before committing. You want to argue through a trade-off without an agent reading and proposing edits.
• Specs and criteria. The first prompt above is a chat task. A precise spec makes the agent task shorter and safer.
• Prose. Release notes, emails, and PR descriptions from material you paste.

Chat is also the right place for a problem you cannot state yet. Move it to an agent once you can write down what “done” looks like.

What goes wrong when you move from chat to an agent?

Symptom	Cause	Recovery
The agent rewrites files you never mentioned	No plan, or the plan was not enforced	Undo the edits (in Claude Code, Esc Esc or /rewind; otherwise git restore the files). Restart in plan or read-only mode and add “touch only the files in the plan” to the prompt
Tests pass, but the bug is still there	The agent weakened or deleted a test, or wrote one that never failed	Check the diff under your test folders first. Ask for the failing run before the fix, and add the rule to AGENTS.md or CLAUDE.md
The agent follows a convention your team dropped	It learned from old code and no instruction file said otherwise	Write the current convention into the instruction file and point at one file that follows it
You paste a long chat transcript into the agent and it drifts	Stale ideas and rejected options from the chat become instructions	Paste only the final acceptance criteria, not the conversation
Usage runs out halfway through a task	Long sessions and repeated full-suite runs use the plan allowance	Check /usage in Codex or Claude Code, split the task, and run only the affected tests while iterating

Two rules apply regardless of the tool. Do not paste secrets into a chat or into a prompt; the agent can read your environment through the permission rules you set. And do not skip the permission prompts with a bypass flag outside a disposable sandbox; see permissions and sandboxing.

Caution

If a chat conversation has passed three rounds of “here is the next file”, stop. Copy the acceptance criteria out, open an agent in the repository, and start again from the criteria. Continuing in chat costs more time than restarting.

Where to go next after plain chat

Run your first Codex task Install Codex, sign in with your ChatGPT plan, and complete one task end to end.

Install Claude Code Set up the CLI and open your first session in a repository.

Build your first feature in Cursor Plan and ship one feature with Cursor's agent.

Cursor vs Claude Code Choose between the IDE-first and the terminal-first agent.

Codex compared with Cursor and Claude Code How Codex's app, CLI, IDE, and cloud surfaces fit together.

Migration guide Move a whole team to an agent: choose, prove on your repo, roll out, measure.