Before You Delegate to an Agent, Build the Table It Works On

🔚 The short version: set the table, don’t just pick the tool

The four pieces I read today came from completely different places, yet they all point the same direction. The better our code-writing tools get, the more the human job shifts from typing to setting the table.

What’s the table? Files that hold the rules (AGENTS.md, CLAUDE.md). Skills that bundle repeated procedures. Notes that get you back up to speed in five minutes after a few days away. And enough fundamentals to notice when an implementation quietly traded away latency for cost.

Here’s what happens without it. The agent looks like it’s working beautifully — right up until your user count grows, and then it falls over.

1. Agents aren’t your pair anymore. They’re your team.

Read the original — How OpenAI says to use Codex (Channel Talk engineering blog, Korean)

🎯 Autocomplete → pair → now you’re the lead

AI coding has moved through three stages: autocomplete, which finishes your line as you type; pair programming, which sits beside you and writes with you; and agentic programming, where you hand off whole tasks and review the outcome.

With each stage, the point where a human steps in moves up a level. You’re no longer intervening on a line of code — you’re intervening at “go do this thing.”

Codex frames that flow in four beats:

Stage	What happens
Delegate	Fire off several long-running tasks in the background at once
Observe	See branches, run logs, diffs, and the browser in one place
Intervene	Add a constraint or change direction mid-flight
Review	Check the diff and test results, then approve

🛠 Nail the team’s rules into a file

AGENTS.md is where you write down “here’s how we work.” Put your repo conventions and verification steps there and the agent moves the same way every time. You can scaffold a draft with /init, too.

Recurring procedures — writing PRs, triaging issues, running tests — get bundled as Skills and shared. That’s where consistency actually comes from.

The part that genuinely surprised me was Record and Replay. For a procedure that’s awkward to describe in words, you record your screen, show it to the agent, and it writes a skill that reproduces the steps. Suddenly YouTube uploads and CRM chores are automatable too. There’s a condition, though: the procedure has to be fixed, and the result has to be verifiable.

💭 So here’s what I decided

I want to stop improvising prompts, AGENTS files, config, skills, plugins, and MCP setups one at a time and start treating them as things I manage. Rebuilding them from scratch every session is exactly what “not setting the table” looks like.

This article also taught me you can call Codex from inside Claude Code. Since Claude is already my main driver, I don’t need to switch — I need an environment where both run side by side.

2. Calling Codex from Claude Code — the actual setup

This is what I looked up right after reading the first piece, based on the official docs.

⚡ You don’t have to migrate

“I’m already on Claude Code — do I have to set everything up again?” Turns out there are two paths.

Path A — stay in Claude Code and call Codex through a plugin
Path B — run /import in Codex CLI to pull your existing setup over

If you want the low-commitment start, A is the one. You keep the interface you know and just compare results.

🔧 Path A — call it through the plugin

Requirements first: a ChatGPT subscription (the Free tier counts) or an OpenAI API key, plus Node.js 18.18 or newer.

Install Codex itself and log in.

npm install -g @openai/codex
codex login

Then run four lines in order inside a Claude Code session.

/plugin marketplace add openai/codex-plugin-cc
/plugin install codex@openai-codex
/reload-plugins
/codex:setup

/codex:setup verifies your installation and auth. Nothing else works until that passes.

Once installed, you get these commands:

Command	What it does
`/codex:review`	General code review of your current work
`/codex:adversarial-review`	A review that attacks your design decisions and assumptions
`/codex:rescue`	Hand a bug investigation or fix over to Codex
`/codex:transfer`	Convert the current session into a Codex thread
`/codex:status` · `/codex:result` · `/codex:cancel`	Check, fetch, or cancel background work

Model and reasoning effort live in .codex/config.toml at the project root.

model = "gpt-5.4-mini"
model_reasoning_effort = "high"

Config precedence runs user level (~/.codex/config.toml) → project level (.codex/config.toml).

📦 Path B — bring your config across with `/import`

Run /import in a Codex session and it populates ~/.codex/config.toml, drafts an AGENTS.md, and hands you a report of everything it skipped or found in conflict.

Claude Code	Codex
`CLAUDE.md`	`AGENTS.md` (renamed, syntax adjusted)
`~/.claude/config.json`	`~/.codex/config.toml`
`.claude/settings.json`	`.codex/config.toml` (project level)
skills / slash commands	folder-based packages under `.agents/skills/`
MCP server config	the `[mcp_servers.*]` section of `config.toml`

One thing to watch: Codex does not read CLAUDE.md. It reads AGENTS.md. That leaves you with two instruction files, so decide on a sync rule up front — treating one as the source and the other as a generated artifact is the easiest arrangement.

And since /import is an automatic conversion, review anything safety-critical yourself: approval policy, sandbox settings, that sort of thing.

📌 Path A’s install commands, command list, and config come from the official codex-plugin-cc README and the OpenAI Developers docs. Path B’s /import details come from a community write-up and may shift between versions — check the report it gives you.

🔀 So can one `AGENTS.md` feed both?

This is where you hit a wall. Claude Code does not read AGENTS.md. It reads CLAUDE.md only. Codex, meanwhile, reads AGENTS.md only. Leave it alone and your instructions split across two files.

Fortunately there’s a way around it. Keep the actual content in AGENTS.md and make CLAUDE.md nothing but a pointer to it.

<!-- CLAUDE.md -->
@AGENTS.md

That’s Claude Code’s @path import syntax, so this single line pulls in everything from AGENTS.md. A symlink (ln -s AGENTS.md CLAUDE.md) works too, though on Windows it needs developer mode or admin rights — I find the import cleaner.

Now you have one source of truth in AGENTS.md, with CLAUDE.md as a pointer. No more copy-pasting rules into two places and watching them drift apart.

📌 Claude Code’s lack of AGENTS.md support is per Anthropic’s docs, and there’s an open issue tracking it. If native support lands, this workaround stops being necessary.

✅ Things you can try today

Run npm install -g @openai/codex and finish codex login
Install the plugin with those four lines in Claude Code and get /codex:setup to pass
Pick one small real task, run it through both systems, and compare the results
Move your instruction content into AGENTS.md and reduce CLAUDE.md to a single @AGENTS.md line

3. Why five minutes is enough to come back days later

Read the original — Ch.14: I opened the todo app again (Why Vibe Coding Fails, Korean)

📓 Without notes, you burn 30 minutes just getting oriented

You open the app again on Monday after a weekend and it’s all fuzzy. How many files were there? What were you about to do next?

But if you left a project overview, a checklist, an architecture note, and a session log in Obsidian, it’s a different story. Opening the session log alone restores “here’s where I stopped, here’s what’s left” in about three minutes.

And without them? The author’s claim is that you open a terminal, skim code, mutter “what was this again,” and lose half an hour.

🎼 Separate the conductor from the site lead

The author splits the work three ways. You are the decision-maker who picks what to build. Claude Desktop is the conductor who sees the whole picture and designs. Claude Code is the site lead who takes the design and actually writes the code.

Throw the same sentence — “I want to add due dates” — at each and you get different reactions.

Conductor → “First let’s decide: store dates as a Date object or an ISO string? Modify the existing component or make a new one?”
Site lead → “Got it, adding a dueDate field” and starts editing immediately

The conductor thinks; the site lead executes. You need both, but the order matters. That’s especially true when you’re extending an existing project rather than starting fresh, since the new feature has to mesh with code that’s already there.

💭 This one’s already how I work

I’m writing this after finishing Why Vibe Coding Fails cover to cover. I layered the book’s method on top of the Obsidian + Claude Code setup I was already running. I didn’t copy it wholesale — the folders and structure I rebuilt my own way!

It’s a genuine case of turning INPUT into OUTPUT. 👍 Honestly it might be the thing I’m most pleased with this year. The whole journey from Notion to Obsidian is getting its own post soon 😃

4. Hiring now looks for “I built with it,” not “I studied it”

Read the original — How to become AX talent: the 5-stage roadmap companies actually verify (Korean)

📈 Evidence over credentials

Job postings with the “AI” keyword hit roughly 15,000 between January and May this year — up 70% year over year. Overall postings grew 10%, so that’s seven times the rate.

The bigger shift is in what counts as evidence. The top capability companies named wasn’t a degree or a certificate — it was hands-on project and field-application experience (32.9%). SK hynix dropping the education requirement for new grads, and hiring hackathons picking finalists on deliverables alone with no résumé screen, are the same current.

🪜 The five stages

Habit (2–4 weeks) — pick one chatbot and use it daily. Summarize, draft, review. The goal here isn’t skill, it’s frequency.
Prompt design (2–4 weeks) — assign a role, supply context, specify the format, iterate. Revising one real work prompt three times beats memorizing a list of 100 great prompts.
Automation (1–3 months) — this is where the gap opens. You stop asking a chatbot things and start restructuring the repetitive work itself. Record the before-and-after time in numbers.
Domain fit (3+ months) — this is what companies actually mean by AX talent. Plenty of people know AI now, but people who can frame their own job’s problems in a form AI can solve are still rare.
Proof (ongoing) — capability nobody can see may as well not exist. Write it up as problem → approach → tools → measured result → limitations, and put it on GitHub or a blog.

⚠️ Three traps to avoid

❌ Becoming a tool collector — browsing new tools isn’t capability. Someone who uses two or three deeply always beats someone who knows ten shallowly.
❌ Shipping unverified output — handing in work with invented figures reads worse than not using AI at all.
❌ Feeding in confidential or personal data — checking your organization’s AI policy first is itself part of the skill set.

5. The agent writes the code; the human picks the trade-offs

Read the original — Andrew Ng on the 7 trade-offs vibe coding misses (Korean)

⚖️ What’s going stale, and what’s getting more expensive

Andrew Ng opens by conceding the point: parts of coding knowledge — memorizing syntax especially — are becoming less useful.

But the next sentence is the whole letter. A developer who deeply understands how software works “vastly” outperforms someone vibe coding without that understanding.

Here’s why. You can build a simple app with no fundamentals at all. The problem is that somewhere along the way the agent makes a bad call on one of seven axes — latency, availability, consistency, reliability, maintainability, simplicity, cost — and the person who delegated never notices.

Know what those bad calls have in common? They work.

Axis	The bad call that’s easy to make quietly
Latency	Querying the DB once per item on a list screen (N+1)
Availability	One external API dies and the whole service stops
Consistency	Concurrent requests decrement the same inventory twice
Simplicity	Eight microservices for a service with ten users
Cost	Reading the full table on every request, and the cloud bill explodes

Every demo passes. Things break when users show up or traffic lands.

🧱 The five fundamentals

Full-stack app building — agents let a specialist widen their range. But you have to be able to read and judge decisions like whether the session belongs in a cookie or on the server.
Data management — the one Ng leaned hardest on. Code can be rewritten in a day; data already piled on top of a bad model can’t. And AI systems pull their own input context from your data sources, which makes your data design the ceiling on your AI output quality.
System architecture — the right architecture is a moving target that shifts with project stage. Say “make it scalable” and you’ll get over-engineering for ten users; say nothing and your prototype structure rides all the way into production.
Security and reliability — test strategy, graceful degradation, minimizing the blast radius of a failure. AI can scan for vulnerabilities, but sorting the real findings out of fifty warnings is still a human job.
Production scaling and ops — CI/CD, observability, incident management. It looks like the most old-fashioned item on the list, and it’s the one gaining weight. When code output multiplies, deploy and detect and respond become the bottleneck.

✅ Things you can try today

Pick a recent agent-built feature and ask it to explain the latency, cost, and consistency trade-offs in that implementation. Any axis whose answer you can’t grade is one of your blanks
Add three lines to AGENTS.md: current stage (prototype vs. first production), expected concurrent users, and what not to do. It’s the cheapest way to tell an agent where that moving target currently is
Add one test that simulates an external API returning a rate limit (429), and watch how your system falls over right now

💡 Wrapping up

This is my second TIR post. I’m deep into building my own AI-native dev environment lately, testing one thing after another.

And the more I do, the more I learn and the closer I get to where AI is actually heading! That’s exactly why I started this blog and opened a TIR category. This wave scared me at first — now it’s genuinely fun.

Next goal is clear: get Codex and Claude Code running side by side! Once it’s set up, I’ll write that process up too 😊

Got questions? Ask away! I’ll help as far as I know. Let’s figure it out together.

Before You Delegate to an Agent, Build the Table It Works On

🔚 The short version: set the table, don’t just pick the tool

1. Agents aren’t your pair anymore. They’re your team.

🎯 Autocomplete → pair → now you’re the lead

🛠 Nail the team’s rules into a file

💭 So here’s what I decided

2. Calling Codex from Claude Code — the actual setup

⚡ You don’t have to migrate

🔧 Path A — call it through the plugin

📦 Path B — bring your config across with /import

🔀 So can one AGENTS.md feed both?

✅ Things you can try today

3. Why five minutes is enough to come back days later

📓 Without notes, you burn 30 minutes just getting oriented

🎼 Separate the conductor from the site lead

💭 This one’s already how I work

4. Hiring now looks for “I built with it,” not “I studied it”

📈 Evidence over credentials

🪜 The five stages

⚠️ Three traps to avoid

5. The agent writes the code; the human picks the trade-offs

⚖️ What’s going stale, and what’s getting more expensive

🧱 The five fundamentals

✅ Things you can try today

💡 Wrapping up

📦 Path B — bring your config across with `/import`

🔀 So can one `AGENTS.md` feed both?