# You've Got The Claude Code CLI Installed — Now What? Plan Mode First, Then CLAUDE.md, Context Hygiene, And The Slash Commands That Matter Follow-on to the AI Terminal Kickstart. The CLI is the runway; the workflow is the plane. Plan mode first, CLAUDE.md as a living contract, the slash commands grouped by intent (/btw /fork /rewind /compact /loop /schedule /simplify /batch /powerup /insights /debug /claude-api), Skills vs Rules vs Memory, Auto Mode boundaries, and a Day 0 to Day 7 ramp plan. Author: J.A. Watte Published: April 24, 2026 Source: https://jwatte.com/blog/ai-terminal-workflow-after-install/ --- _This is the follow-on to **[AI Terminal Kickstart](/blog/blog-ai-terminal-kickstart/)** (the install primer). That post got Claude Code, Codex, ChatGPT CLI, GitHub Copilot CLI, and Netlify CLI onto a fresh machine. This post starts where that one stops — you have the binary, you can type `claude`, and the blinking cursor is now staring back at you. What do you actually type first, and why?_ --- **📚 The full series — Claude Code track + Codex mini-series:** **Claude Code track:** 1. **[AI Terminal Kickstart](/blog/blog-ai-terminal-kickstart/)** — install the CLIs on a fresh machine (starting point). 2. **You've Got The CLI Installed — Now What?** (this post) — plan mode, CLAUDE.md, slash commands overview, Day 0 → Day 7 ramp. 3. **[Skills, Rules, Memory — deeper dive](/blog/claude-code-skills-rules-memory-deep-dive/)** — the four-layer hierarchy with real migration examples. 4. **[Adversarial subagents + worktree isolation](/blog/claude-code-adversarial-subagents-worktrees/)** — Boris Cherny's parallel-Claudes review pattern, in practice. 5. **[Hooks implementation guide](/blog/claude-code-hooks-approval-fatigue/)** — kill approval fatigue with 5 concrete hook recipes. 6. **[/loop vs /schedule](/blog/claude-code-loop-vs-schedule/)** — watchdog vs alarm clock, with working example tasks. 7. **[CLAUDE.md anti-patterns](/blog/claude-md-anti-patterns/)** — the 8 patterns that cause your file to rot. 8. **[Auto Mode case studies](/blog/claude-code-auto-mode-case-studies/)** — four real cases where the classifier got it right, wrong, and almost right. 9. **[/insights-driven iteration](/blog/claude-code-insights-iteration-workflow/)** — the 30-minute Monday ritual that compounds. 10. **[Remote Control + Channels](/blog/claude-code-remote-control-channels/)** — iMessage / Telegram / Discord dispatch setup. 11. **[Multi-model routing](/blog/claude-code-multi-model-routing/)** — when to break out of Claude-only. 12. **[Agent skill marketplace](/blog/claude-code-agent-skill-marketplace/)** — Skills 2.0, evaluating before installing, publishing your own. **Codex mini-series (OpenAI CLI companions):** 1. **[Codex CLI after install](/blog/codex-cli-after-install/)** — OpenAI-specific first-week habits, model selection, cost mechanics. 2. **[Codex vs Claude Code — task-level comparison](/blog/codex-vs-claude-code-comparison/)** — where each one actually wins. 3. **[Prompt style — GPT vs Claude](/blog/prompt-style-gpt-vs-claude/)** — the four stylistic differences that matter in practice. 4. **[ChatGPT CLI / Codex CLI / GitHub Copilot CLI — positioning](/blog/chatgpt-codex-copilot-cli-positioning/)** — three products that sound alike and do different jobs. 5. **[Two-CLI workflow](/blog/two-cli-workflow-codex-claude-code/)** — split-screen routine for running Codex + Claude Code in parallel. **Open-weights + Google-stack track:** 1. **[Qwen self-hosted at home](/blog/qwen-open-weights-self-hosted-at-home/)** — when open-weights beats proprietary, hardware tiers, Ollama setup, quantization trade-offs. 2. **[Gemini CLI — when to use](/blog/gemini-cli-when-to-use/)** — long context, multimodal, Google-ecosystem fit, and where Gemini falls short against Claude Code. 3. **[Gemma — where it fits next to Qwen](/blog/gemma-open-weights-where-it-fits/)** — Google's open-weights counterpart; when to pick it over Qwen and vice versa. --- > 🆕 **Updated June 2026.** Since this first published, Claude Code shipped Remote Control, the Opus 4.8 default, dynamic workflows, the `claude agents` view, `/goal`, and the `/simplify` to `/code-review` split. Three new sections near the end cover all of it: remote control, what else shipped, and how Codex now pairs with Claude Code. The short answer: **plan before edit, narrow context before prompting, and turn anything you repeat twice into an artifact the next session inherits.** The long answer is the rest of this post. ## The CLI is the runway, not the plane A common mistake after install is treating Claude Code as a smarter autocomplete — ask a question, paste the answer, move on. That works for the first few sessions. It degrades once the project grows past 10 or 20 files, because the model is making decisions without a shared understanding of the repo, your conventions, or what you've already tried. The friction shows up as: re-explaining the same constraints every session, fighting Claude about a convention you thought you'd agreed on three sessions ago, or ending the day with six tabs of abandoned sessions you can't remember the state of. The fix is an **operating model** — an explicit structure for how you plan, execute, track context, and hand off between sessions. Anthropic's internal practice and public essays from Boris Cherny (creator of Claude Code), Andrej Karpathy, and other power users converge on the same five habits: 1. **Always-on context stays small.** The stuff in every prompt lives in CLAUDE.md, not in the chat. 2. **Repeated procedures become skills or slash commands.** You stop typing the same 10-line setup each session. 3. **Active sessions are protected from pollution.** You use `/btw`, `/fork`, `/rewind`, and `/compact` to keep the main thread coherent. 4. **Parallel work is isolated.** Worktrees and subagents run in their own sandboxes so they don't step on each other. 5. **Guardrails remove noise, not judgment.** Auto Mode, hooks, and rules handle routine approvals so you only see the prompts that actually need review. Install is done. Adopting the operating model is the rest of the work. ## Before anything else — turn on plan mode The single highest-leverage habit after install is telling Claude to **plan before editing**. Not "start writing code," not "go implement X." Plan. A plan-first prompt looks roughly like: ``` /plan Before you touch any files, produce a plan for . Include: 1. Which files will change and why 2. The order of changes 3. Risks + edge cases 4. A short acceptance-test list Do not edit anything until I approve the plan. ``` Two things happen. First, Claude commits to a structure you can read and push back on before code gets written. Catching "actually, don't refactor this helper, just extend the caller" at plan time is a 30-second fix; catching it after Claude has rewritten 400 lines is a cleanup pass. Second, the plan becomes a checklist you can reference for the rest of the session — "we said we'd skip the auth changes for now, please don't touch `src/auth/`." You can also launch in plan mode from the CLI: ```bash claude --permission-mode plan "Refactor the checkout flow to extract into a reusable module" ``` And there's a settings-level default if you want every session to start in plan mode until you cycle out: ```json { "permissions": { "defaultMode": "plan" } } ``` Plan mode is not a ceremony. It is the difference between a session that compounds and a session that churns. For anything that touches more than one file — use it. ## CLAUDE.md as a living contract Once plan mode is your default posture, the second-highest-leverage habit is maintaining a real CLAUDE.md at the root of every project. **What goes in:** - Project purpose in one paragraph (what this repo does, who uses it) - Stack (languages, frameworks, runtimes, deploy target) - Code-style preferences (naming, module layout, test conventions) - Commands (dev server, build, test, deploy) — every routine command with its exact flag set - External services (APIs, env var names — never values) - Anti-patterns — things you've already decided not to do, with a one-sentence reason each - Known quirks — surprising behaviors that a new session would otherwise stumble into **What stays out:** - Secrets. Ever. Use env var names only. - Per-session state. CLAUDE.md is for always-true facts, not "we're currently working on branch X." - Documentation a human reader wouldn't want. If a line isn't useful to a person onboarding to the repo, it isn't useful to Claude. **What makes it a living contract:** every session updates it. Finished a refactor that changed an anti-pattern? Update CLAUDE.md. Discovered a quirk that bit you mid-session? Add it. The file's signal-to-noise improves across weeks, and the model spends less time re-discovering things the file already knows. A useful discipline: at the end of each session, spend 30 seconds asking _"what did I just learn that the next session should know by default?"_ and put it in CLAUDE.md. The compounding is why Boris Cherny's published workflows describe CLAUDE.md as _"the living contract."_ Further reading: Arize's [CLAUDE.md best practices](https://arize.com/blog/claude-md-best-practices-learned-from-optimizing-claude-code-with-prompt-learning/) has a prompt-learning framing; Anthropic's [Effective context engineering for AI agents](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents) covers the theory. ## The slash commands that matter, grouped by intent Claude Code ships with a lot of slash commands, and the list keeps growing. Grouping them by **what you're trying to accomplish** makes them easier to keep in working memory than trying to memorize the list. ### Learning the surface - **`/powerup`** — built-in interactive onboarding. Run it after any Claude Code update. It walks you through features that most users never discover (hooks, subagents, worktrees, rewind, skills, MCP). Fifteen minutes, high-signal. - **`/insights`** — analyzes your last ~30 days of sessions and writes an HTML report (usually to `~/.claude/usage-data/report.html`). Shows where time and tokens go, which sessions you abandoned, recurring friction points. The actionable pattern: take the top 1–3 friction points from `/insights` and fix each one by promoting a rule into CLAUDE.md, creating a skill, or adding a hook. ### Context hygiene (keep the main thread coherent) - **`/btw`** — cheap single-turn side channel. "By the way, what's the difference between X and Y?" Claude answers from the existing prompt cache without consuming turns or polluting the main thread. Read-only; can't edit files or call new tools. - **`/fork`** — clones the current session into a new one that inherits conversation history up to the fork point. Use when you want to explore an alternative approach deeply without throwing away the main thread. `claude -r "session-name" --fork-session` from the CLI opens the fork in a second terminal. - **`/rewind`** — surgical state restoration. When pollution is already in the thread (bad path, wrong file read, misremembered context), `/rewind` rolls back to a checkpoint. Fastest trigger is **Esc twice**. - **`/compact`** — compresses the current context window in place, keeping working state but dropping raw history. Use when the context is not wrong, just large. Quick selection: **question → `/btw`. Alternative exploration → `/fork`. Wrong direction → `/rewind`. Too big but correct → `/compact`.** (Reference: [Mastering Claude Code's /btw, /fork, and /rewind](https://getpushtoprod.substack.com/p/how-the-creator-of-claude-code-actually) and the official [slash-commands docs](https://code.claude.com/docs/en/slash-commands).) ### Automation - **`/loop `** — in-session recurring prompt. `/loop 30m run tests and summarize failures` turns your session into a watcher. Shines for polling compilation, watching deploys, or auto-regenerating summaries. Lightweight, lives inside the running session. - **`/schedule`** — cron-style scheduling of remote agent routines. Runs even when no session is open. Use for: nightly test runs, weekly dependency audits, morning "open issues + PRs summary" reports. (Official: [Scheduled tasks docs](https://code.claude.com/docs/en/scheduled-tasks).) Rule of thumb: `/loop` is for "watch this while I work." `/schedule` is for "do this even when I'm not here." ### Multi-agent work (bounded, isolated, reviewable) - **`/code-review`** (renamed from `/simplify`) — review the current diff for correctness bugs plus reuse, simplification, and efficiency cleanups at a chosen effort level. `--comment` posts findings as inline PR comments, `--fix` applies them to the working tree, and `/code-review ultra` runs the deeper cloud review. The standalone **`/simplify`** is now cleanup only: it applies quality fixes without hunting for bugs. (More in the update sections near the end.) - **`/batch`** — the most ambitious bundled command. Decomposes a single change description ("migrate src/ from Solid to React") into 5–30 independent units, spawns one agent per unit in an **isolated git worktree**, each implements + tests + opens a PR. Review the plan before approving; decomposition quality determines everything downstream. - **Subagents** — spawn a task-shaped sub-Claude with its own clean context to do a bounded research job. Used adversarially in Cherny's workflow: two subagents with different review roles critique each other before you accept. (Official: [Subagents docs](https://code.claude.com/docs/en/sub-agents).) - **Worktrees** — `claude --worktree feature-auth` (or `-w`) creates an isolated git worktree for parallel work. Five parallel Claude sessions each on their own worktree is Cherny's published default for complex tasks. Collisions are impossible because each agent has its own checkout. ### Debugging - **`/debug`** — when Claude Code itself is misbehaving (hooks failing, Bash tool weirdness, skills not loading), `/debug` reads the session debug log and diagnoses. Accepts a hint: `/debug why is the Bash tool failing?`. Run this before filing a GitHub issue; it often finds the config problem. - **`/claude-api`** — activates automatically when a repo imports `anthropic`, `@anthropic-ai/sdk`, or `claude_agent_sdk`. Loads the relevant SDK reference (tool use, streaming, batches, structured output, prompt caching, common pitfalls) so Claude is "API-smart" in that repo without you having to paste docs. ## Skills, Rules, Memory — progressive disclosure Stuffing everything into one giant CLAUDE.md is the second-most-common mistake after install (first is typing "go" before planning). The pattern that scales is **progressive disclosure** — four layers, each smaller and more situational than the last. - **CLAUDE.md** — always-true facts that apply every turn of every session. Project purpose, stack, deploy command. Every prompt sees this. - **Rules** — file-scoped or directory-scoped constraints. "Files in `src/auth/` must pass the security-review checklist before merge." Applies only when Claude is touching that path. Split rules out of CLAUDE.md when the file grows past ~200 lines — smaller, scoped files are faster for the model to apply correctly. - **Skills** — repeatable procedures packaged as invokable artifacts. A skill is a named, parameterized recipe ("run the pre-deploy check," "rebuild the tool-nav block"). Invoked with a slash command or referenced by other agents. The 2026 evolution: [Skills 2.0 makes skills programmable](https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills) — they can take inputs, return structured output, be composed with other skills. - **Memory** — learned facts saved across sessions. "User prefers functional Svelte components over class-based." "The NextDNS account uses profile ID X." Memory is the persistence layer _between_ sessions; CLAUDE.md is the persistence layer _within_ sessions. When to use which: **always-true → CLAUDE.md. Scoped → rule. Repeatable workflow → skill. Learned fact from past conversations → memory.** (Reference: [Save Hours: Stop Repeating Yourself to Claude: Skills, Rules, Memory](https://juliangoldie.com/claude-skills/) — breaks down the boundaries by example.) ## Hooks — making Claude deterministic for the boring parts Hooks are shell commands the harness runs in response to events — before a tool call, after a file edit, on session close. They're how you make certain actions deterministic so Claude isn't asked to remember them every time. Practical hook examples: - **`PreToolUse` before Bash** — auto-approve any command matching a known-safe regex (`^npm (test|run build|run lint)$`), block the rest. - **`PostToolUse` after Edit** — run `npx eslint --fix` + `prettier --write` on the edited file so formatting is never something Claude has to get right manually. - **`Stop`** — write a session summary to `~/.claude/session-log/.md` on session close. - **`UserPromptSubmit`** — prepend the current git branch + diff status to every prompt so Claude always knows the repo state. (Reference: [Claude Code Hooks: Making AI Gen Deterministic](https://www.freecodecamp.org/news/claude-code-handbook/) and the [Hooks Implementation Guide: Audit System](https://github.com/RiyaParikh0112/claude-code-playbook/blob/main/docs/fundamentals/security-best-practices.md).) Hooks are where a mature workflow pulls ahead of a casual one. Casual users approve the same `npm test` 30 times a day; mature users wrote a hook on day 3 and never see that prompt again. ## Auto Mode — when it's a win, when it's a trap Anthropic's March 2026 [Auto Mode](https://www.anthropic.com/engineering/claude-code-auto-mode) uses model-based classifiers to screen proposed actions, letting routine operations proceed and escalating the risky ones. Enabled via: ```bash claude --enable-auto-mode ``` Then inside a session, **Shift+Tab** cycles through permission modes until "auto" is active. **When Auto Mode is a win:** - Trusted local developer environment. Your own repo, your own machine, no production systems in the loop. - Tasks with clear rollback (anything under git; anything on a branch that can be force-reset). - Routine actions that you would otherwise click-through approve anyway — lint fixes, file renames, dependency installs from known registries. **When Auto Mode is a trap:** - Untrusted environments or any repo where a prompt-injection could reach shared infrastructure. - Production deploys. Explicit gate every time. - High-blast-radius operations (database schema changes, DNS edits, credential rotations). Even the classifier catches most of these, but "most" is not "all." - Regulated work where you need to defend every action in an audit. The right mental model: Auto Mode reduces **approval fatigue** without eliminating **approval judgment**. The classifier is good at the routine middle; it is not a substitute for a human on the risky edges. Anthropic is explicit about this in the official essay — Auto Mode is a better trade inside trusted dev environments, not a universal answer. Pair Auto Mode with hooks that have explicit `deny` rules for commands you never want auto-approved — that's the combination that actually feels safe. ## The /insights iteration loop — most-overlooked daily habit Most install-then-use flows stop at "I can get Claude to do things now." The tier-up is **measuring what's working and iterating**. `/insights` produces a local HTML report: tool-usage patterns, where tokens go, which sessions you abandoned, what caused restart loops. Read the report. Pick the top 1–3 friction points. For each: - **Friction: "I keep re-explaining the deploy command."** → promote it into CLAUDE.md's Commands section. - **Friction: "The same pre-flight check before every deploy."** → package as a skill. - **Friction: "Approvals for known-safe Bash commands slow me down."** → add a hook with an allowlist. - **Friction: "Long sessions get incoherent after the third topic switch."** → build the habit of `/fork`ing before a topic switch, not after. Run `/insights` weekly. The signal the first time is usually obvious (one or two big drags). Subsequent weeks surface subtler drags. The workflow quality curve rises whenever you're willing to treat the report as a checklist, not a dashboard. ## Visual workflow — what to reach for when
New task or question Start here — pick by intent Will this touch > 1 file? Yes → /plan first. No → straight prompt fine. Quick side question read-only, single-turn → /btw Explore an alternative without polluting main thread → /fork Thread went wrong way bad path in context, need a clean slate at a checkpoint → /rewind (or Esc Esc) Context big but correct compress, keep working → /compact Recurring poll in-session tests, deploys, builds, status → /loop Scheduled even when offline nightly jobs, weekly summaries, cron-style → /schedule Post-implementation review find reuse, bugs, perf wins → /simplify Big migration, many files decompose into worktrees + parallel agents → /batch
Pick-by-intent cheat sheet. The vertical branches aren't sequential — they're different situations you'll hit on different days.
## Day 0 through Day 7 — a ramp plan A short onboarding ramp, assuming you just finished the [install primer](/blog/blog-ai-terminal-kickstart/): **Day 0 (install + first session).** You already did the install primer. First session: `claude` in any repo, `/powerup` walkthrough, then ask Claude to read the repo and produce a one-page summary. Close. **Day 1 (CLAUDE.md).** In the project you care about most, open `CLAUDE.md` and write it. Stack, purpose, commands, code-style preferences, anti-patterns. Ten to fifteen minutes. Commit it. **Day 2 (plan mode as default).** For every session: `/plan` first. Read the plan, push back, approve. Do this even for tasks you think are trivial — the plan is also the session log. **Day 3 (first hook).** Pick the most annoying repeated approval — for me it was `npm test` — and write a hook that auto-approves it. Live without the prompt for a day and feel the difference. **Day 4 (/insights first run).** Run `/insights`. Read the HTML report. Pick the top single friction point. Fix it (CLAUDE.md edit, new hook, or new skill). **Day 5 (context hygiene).** Practice the `/fork` habit. Next time you're tempted to "just quickly ask something unrelated" in the main thread, `/fork` instead. Do this three times and it becomes muscle memory. **Day 6 (first /loop).** Set up a real `/loop` — the classic is `/loop 10m run tests and summarize failures`. Leave it running during a real work session. Feel the ambient awareness. **Day 7 (first /batch or /simplify).** When your next feature lands, `/simplify` it. When your next refactor is bigger than one file, `/batch` the plan. The ceiling of what's worth doing with Claude Code rises fast once you're using the multi-agent commands. By Day 7 you've installed, adopted plan-first, written CLAUDE.md, added a hook, run `/insights`, practiced context hygiene, set up a loop, and done your first multi-agent review. That's the curve from "I have it installed" to "I have an operating model." Past this point, the marginal improvements come from iterating on what `/insights` shows you each week — skills, rules, and memory grow as your work does. ## Remote control: drive a running session from your phone or browser The biggest addition since this post first published is Remote Control. It keeps a Claude Code session running on your machine, with your files, MCP servers, and project config all intact, and gives you a second window into that session from your phone, a browser on another computer, or VS Code. Start a task at your desk, walk away, and keep steering it. Three ways to turn it on: - `claude --remote-control "My Project"` (alias `--rc`) starts a normal terminal session that is also reachable remotely, so you keep typing locally while the phone stays available. This is the everyday choice. - `/remote-control` (or `/rc`) flips a session you already started, carrying its history over. - `claude remote-control` runs a server that can host several sessions at once. Each prints a session URL and a QR code. Open the URL in any browser, scan the QR with the Claude app, or open claude.ai/code and pick the session by name. To make it automatic for every session, set "Enable Remote Control for all sessions" in `/config`. Why it is efficient, not just convenient: there is no re-setup tax, because it is the same session with your local environment attached. The conversation stays in sync across devices, so you can move between terminal, browser, and phone without losing the thread. It survives a laptop sleep or a network blip and reconnects on its own. And mobile push notifications (run `/config` and enable "Push when Claude decides") mean a long build or test run pings you when it finishes or when it needs a decision, so you stop watching progress bars. You can even ask for one in a prompt: "notify me when the tests finish." The security model is the reassuring part. Your session makes outbound HTTPS requests only and never opens an inbound port. It registers with the Anthropic API and polls for work over TLS, using short-lived credentials scoped to a single purpose. Nothing tunnels into your laptop. You need v2.1.51 or later, a Pro, Max, Team, or Enterprise plan, and a claude.ai login (API keys are not supported). The full walk-through, including Channels (push iMessage, Telegram, Discord, or a CI webhook into the session) and Dispatch (start a session from a text), is in the dedicated post: [Remote Control + Channels](/blog/claude-code-remote-control-channels/). ## What else shipped since this post first went up Claude Code moved fast in May 2026. The headline release was Opus 4.8, and a batch of workflow features came with it. The short version: - **Opus 4.8 is the new default model** on Max, Team Premium, Enterprise pay-as-you-go, and API tiers (Pro and Team Standard seats still default to Sonnet 4.6). Fast mode runs the same model at up to 2.5x the output speed for 2x the standard rate. There is a new top effort tier, `/effort xhigh`, for the hardest tasks, though Opus 4.8 itself defaults to "high." - **Dynamic workflows** (`/workflows`) let Claude write a small orchestration script that runs tens to hundreds of background subagents while your session stays responsive. The in-prompt trigger keyword was renamed from "workflow" to "ultracode," and `/effort ultracode` sets xhigh plus automatic workflow orchestration. `/deep-research` is a bundled workflow that fans out web searches and returns a cited report. - **The agent view** (`claude agents`) is a dashboard for every background session: dispatch new ones, see what is running, what needs input, and what is done, and attach only when you care. - **Background sessions** got first-class commands: `claude --bg ""` starts one detached, `claude --bg --exec ''` runs a shell command as a background job, and `/bg` pushes a running session into the background. - **`/goal`** sets a completion condition and keeps Claude working across turns until a small fast model confirms the goal is met, with a live elapsed-and-token overlay. - **`/code-review`** is the renamed `/simplify`: it reviews the current diff for correctness bugs plus cleanups at an effort level, posts inline PR comments with `--comment`, and applies fixes with `--fix`. The new `/simplify` is cleanup only. - **Plugins** load automatically from `.claude/skills` with no marketplace, `/reload-skills` picks up new ones without a restart, and `claude plugin init` scaffolds your own. - **Auto Mode no longer requires opt-in consent**, which makes the boundaries discussed above the live default rather than a flag you remember to set. For the full breakdown, see [what shipped since you installed Claude Code](/blog/claude-code-whats-new-since-install/). ## Codex moved too, and the two pair well If you run OpenAI's Codex alongside Claude Code (the [two-CLI workflow](/blog/two-cli-workflow-codex-claude-code/)), it changed just as much. Codex now defaults to gpt-5.5 for ChatGPT sign-in sessions, with gpt-5.4-mini as the cheap option for exploration and subagents (API-key sessions may still point at gpt-5.2-codex, so check before you assume). It also picked up the same shapes Claude Code has: a Goal Mode, subagents, permission profiles instead of a blanket full-auto, an in-app browser and computer use, hooks, plugins, MCP, and its own remote control. The reason to run both is that their strengths are genuinely complementary, not redundant. A few patterns that work: - **Plan in Claude Code, execute in Codex.** Claude reasons well about ambiguous, big-picture "what should we do" questions. Codex is strong at deterministic, mechanical execution across many files with each step verified against tests. Generate a structured plan in Claude, paste it into Codex to carry out. - **Use the official Codex plugin for Claude Code.** OpenAI shipped a plugin (codex-plugin-cc) that brings Codex into a Claude Code session for a standard review, a more skeptical adversarial review, or a handoff so a different model takes a second pass. Cross-model review catches bugs that a model reviewing its own work tends to miss, and it runs through your local Codex install, reusing its auth and config. - **Codex executes unattended, Claude reviews.** Let Codex run a batch or overnight job and open a PR, then have Claude Code do the architectural review on the diff. Codex brings throughput, Claude brings judgment. - **Route by task shape.** A common team habit is Claude for ambiguous, visual, or multi-agent work and Codex for tight, well-scoped, cost-conscious tasks. Some people literally alias `plan=claude` and `do=codex`. Prices and exact model defaults drift, so confirm current pricing and which model your auth method gets before you wire any of this into a routine. ## Common pitfalls (the ones that cost the most time) - **"I dumped everything into one giant CLAUDE.md."** Split by concern — always-true facts stay in CLAUDE.md, file-scoped constraints become rules, repeatable workflows become skills, learned facts become memory. Progressive disclosure beats prompt hoarding. - **"I keep approving the same prompt 30 times."** That's a hook you haven't written yet. - **"My session is now a mess and I can't remember what we decided."** `/rewind` to a checkpoint, or `/fork` to archive the current thread and continue clean. - **"Parallel agents keep colliding."** That's the worktree pattern. `claude --worktree ` for every parallel task. - **"I started in plan mode but then forgot and Claude edited 800 lines."** Set `"defaultMode": "plan"` in settings. Let the friction happen; it's the cheap end of the error spectrum. ## Related reading - **[AI Terminal Kickstart](/blog/blog-ai-terminal-kickstart/)** — the beginner primer. Install Claude Code, Codex, ChatGPT CLI, GitHub Copilot CLI, Netlify CLI. Prereq for everything in this post. - **[ISP surveillance + DIY monitoring](/blog/isp-surveillance-and-diy-monitoring/)** — tangentially related: if you're running Claude Code in a small-business context, the network isolation from that post matters for what Claude sees. - **[Isolating IoT Devices On A Consumer Router](/blog/iot-network-isolation-consumer-router/)** — same theme, different layer — segment your network before you segment your sessions. - **[Claude MD Generator](/tools/claude-md-generator/)** — companion tool: generates a CLAUDE.md scaffold from basic project inputs. Use it to bootstrap the file described in this post. ## Fact-check notes and sources Primary sources for the workflow patterns in this post: - **Anthropic Engineering** — [Harness design for long-running application development](https://www.anthropic.com/engineering/harness-design-long-running-apps), [Effective context engineering for AI agents](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents), [Equipping agents for the real world with Agent Skills](https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills), [Auto Mode: a safer way to skip permissions](https://www.anthropic.com/engineering/claude-code-auto-mode), [How Anthropic teams use Claude Code](https://claude.com/blog/how-anthropic-teams-use-claude-code). - **Official Claude Code docs** — [Slash commands](https://code.claude.com/docs/en/slash-commands), [Scheduled tasks](https://code.claude.com/docs/en/scheduled-tasks), [Subagents](https://code.claude.com/docs/en/sub-agents), [Remote Control](https://code.claude.com/docs/en/remote-control), [Memory](https://docs.anthropic.com/en/docs/claude-code/memory), [Changelog](https://code.claude.com/docs/en/changelog). - **Boris Cherny** (Claude Code creator) — [How I use Claude Code](https://x.com/bcherny/status/2007179832300581177) and the writeup at [howborisusesclaudecode.com](https://howborisusesclaudecode.com). Also covered in [Every's podcast](https://every.to/podcast/how-to-use-claude-code-like-the-people-who-built-it), [InfoQ](https://www.infoq.com/news/2026/01/claude-code-creator-workflow/), and [Pragmatic Engineer — How Claude Code is built](https://newsletter.pragmaticengineer.com/p/how-claude-code-is-built). - **Andrej Karpathy** — ["Claude agents on the left, IDE on the right"](https://x.com/karpathy/status/2015883857489522876) + [Business Insider analysis](https://www.businessinsider.com/andrej-karpathy-claude-code-manual-skills-atrophy-software-engineering-tesla-2026-1). - **Practical field notes** — [The Claude Code Handbook at freeCodeCamp](https://www.freecodecamp.org/news/claude-code-handbook/), [Paddo — 10 tips from inside the Claude Code team](https://paddo.dev/blog/claude-code-team-tips/), [CodingScape — how Anthropic engineering teams use Claude Code every day](https://codingscape.com/blog/how-anthropic-engineering-teams-use-claude-code-every-day). - **Context hygiene toolkit** — [Mastering /btw, /fork, and /rewind](https://getpushtoprod.substack.com/p/how-the-creator-of-claude-code-actually). - **Q1 2026 feature surface** — [MindStudio Q1 2026 update roundup](https://www.mindstudio.ai/blog/claude-code-q1-2026-update-roundup/) + [Q1 2026 roundup part 2](https://www.mindstudio.ai/blog/claude-code-q1-2026-update-roundup-2/). - **Q2 2026 feature surface** — official docs for [Fast mode](https://code.claude.com/docs/en/fast-mode), [Dynamic workflows](https://code.claude.com/docs/en/workflows), [Agent view](https://code.claude.com/docs/en/agent-view), [`/goal`](https://code.claude.com/docs/en/goal), and [`/code-review`](https://code.claude.com/docs/en/code-review); the [Opus 4.8 announcement](https://www.anthropic.com/news/claude-opus-4-8). Codex side: [Codex models](https://developers.openai.com/codex/models), [Codex changelog](https://developers.openai.com/codex/changelog), and the [Codex plugin for Claude Code](https://community.openai.com/t/introducing-codex-plugin-for-claude-code/1378186). - **CLAUDE.md discipline** — [Arize: CLAUDE.md best practices from prompt learning](https://arize.com/blog/claude-md-best-practices-learned-from-optimizing-claude-code-with-prompt-learning/), [Walturn: prompt engineering for Claude](https://www.walturn.com/insights/mastering-prompt-engineering-for-claude). - **Skills + rules + memory breakdown** — [Save Hours: Stop Repeating Yourself to Claude](https://juliangoldie.com/claude-skills/). - **Security / boundaries** — [MintMCP — Claude Code security](https://www.mintmcp.com/blog/claude-code-security), [Claude Code playbook — security best practices](https://github.com/RiyaParikh0112/claude-code-playbook/blob/main/docs/fundamentals/security-best-practices.md). *This post is informational, not engineering consulting advice. The slash commands, flags, and settings referenced reflect Claude Code's Q1 and Q2 2026 surface (through version 2.1.162); re-verify against the [official changelog](https://code.claude.com/docs/en/changelog) before depending on any specific command in production. Mentions of Anthropic, Claude Code, OpenAI, GitHub, Netlify, and all third-party authors / publications are nominative fair use. No affiliation is implied.* --- Canonical HTML: https://jwatte.com/blog/ai-terminal-workflow-after-install/ RSS: https://jwatte.com/feed.xml JSON Feed: https://jwatte.com/feed.json Hero image: https://jwatte.com/images/ai-terminal-workflow-after-install.webp