Agentic Recipes & Power Patterns

"We recommend using the word think to trigger extended thinking mode… 'think' < 'think hard' < 'think harder' < 'ultrathink'. Each level allocates progressively more thinking budget."

"Ask Codex to interview you: If you have a rough idea of what you want but aren't sure how to describe it well, ask Codex to question you first. Tell it to challenge your assumptions and turn the fuzzy idea into something concrete before writing code."

"A good default is to include four things in your prompt: Context (which files, folders, docs matter), Task (what to do), Constraints (boundaries), and Verification (what 'good' looks like). This provides the clearest path to a useful result."

"Don't stop at asking Codex to make a change. Ask it to create tests when needed, run the relevant checks, confirm the result, and review the work before you accept it. Codex can do this loop for you, but only if it knows what 'good' looks like."

"Use Plan mode: For most users, this is the easiest and most effective option. Plan mode lets Codex gather context, ask clarifying questions, and build a stronger plan before implementation."

"Batch everything. If you need multiple files (even from different places), read them together. Only make sequential calls if you truly cannot know the next file without seeing a result first."

"challenge Claude — 'grill me on these changes and don't make a PR until I pass your test.' or 'prove to me this works' and have Claude diff between main and your branch."

"use Esc Esc or /rewind to undo when Claude goes off-track instead of trying to fix it in the same context."

"At 70% context, Claude starts losing precision. At 85%, hallucinations increase. At 90%+, responses become erratic. Strategy: 0-50% (work freely). 50-70% (attention). 70-90% (/compact). 90%+ (/clear mandatory)."

"avoid agent dumb zone, do manual /compact at max 50%. Use /clear to reset context mid-session if switching to a new task."

"Context is infrastructure. Claude Code automatically pulls context from your environment. Rather than treating Claude as a chatbot, the core insight is: Claude Code works best when treated like a junior engineer with tools, memory, and iteration."

"Codex ran for about 25 hours uninterrupted, used about 13M tokens, and generated about 30k lines of code. This performed well on the parts that matter for long-horizon work: following the spec, staying on task, running verification, and repairing failures."

"A fresh context improves code review since Claude won't be biased toward code it just wrote. For example, use a Writer/Reviewer pattern. You can do something similar with tests: have one Claude write tests, then another write code to pass them."

"have one Claude write tests, then another write code to pass them. Loop through tasks calling claude -p for each. Use --allowedTools to scope permissions for batch operations."

"Have Claude list all files that need migrating. for file in $(cat files.txt); do claude -p 'Migrate $file from React to Vue. Return OK or FAIL.' --allowedTools 'Edit,Bash(git commit *)' done"

"Loop through tasks calling claude -p for each. Use --allowedTools to scope permissions for batch operations."

"say 'use subagents' to throw more compute at a problem — offload tasks to keep your main context clean and focused."

"Define specialized assistants in .claude/agents/ that Claude can delegate to. --- name: security-reviewer description: Reviews code for security vulnerabilities tools: Read, Grep, Glob, Bash model: opus ---"

"agent teams with tmux and git worktrees for parallel development… use test time compute — separate context windows make results better; one agent can cause bugs and another (same model) can find them."

"Parallel task execution. This is Codex's killer feature. Assign 5 different tasks, each runs in its own isolated container, and you review all 5 when they're done."

"use slash commands for every 'inner loop' workflow you do many times a day — saves repeated prompting, commands live in .claude/commands/ and are checked into git."

"build a Gotchas section in every skill — highest-signal content, add Claude's failure points over time."

"skill description field is a trigger, not a summary — write it for the model ('when should I fire?') don't state the obvious in skills — focus on what pushes Claude out of its default behavior."

"don't railroad Claude in skills — give goals and constraints, not prescriptive step-by-step instructions."

"embed !`command` in SKILL.md to inject dynamic shell output into the prompt — Claude runs it on invocation and the model only sees the result."

"If the task is complex, ambiguous, or hard to describe well, ask Codex to plan before it starts coding."

"To provide context faster, try using speech dictation inside the Codex app to dictate what you want Codex to do rather than typing it."

"Keep each skill scoped to one job. Start with 2 to 3 concrete use cases, define clear inputs and outputs… Don't try to cover every edge case up front."

"/rename important sessions (e.g. [TODO - refactor task]) and /resume them later — label each instance when running multiple Claudes simultaneously."

"use /model to select model and reasoning… use Opus for plan mode and Sonnet for code to get the best of both."

"Claude fixes most bugs by itself — paste the bug, say 'fix', don't micromanage how."

"keep codebases clean and finish migrations — partially migrated frameworks confuse models that might pick the wrong pattern."

"use browser automation MCPs (Claude in Chrome, Playwright, Chrome DevTools) for Claude to inspect console logs."

"This creates a closed feedback loop where the agent evaluates its own output."

"after a mediocre fix — 'knowing everything you know now, scrap this and implement the elegant solution'."

"Add tools only when they unlock a real workflow. Do not start by wiring in every tool you use. Start with one or two tools that clearly remove a manual loop you already do often."

"The Model Context Protocol (MCP) turns Claude into a tool-orchestrating agent rather than a single-model assistant. Query monitoring tools (e.g. Sentry). This is a foundational step toward AI-native developer environments."

"Run /plugin to browse the marketplace. Plugins add skills, tools, and integrations without configuration."

"Use --output-schema to request a final response that conforms to a JSON Schema. This is useful for automated workflows that need stable fields (for example, job summaries, risk reports, or release metadata)."

"When you enable --json, stdout becomes a JSON Lines (JSONL) stream so you can capture every event Codex emits while it's running. Event types include thread.started, turn.started, turn.completed, item.*, and error."

"24 CVEs identified in Claude Code ecosystem. 655 malicious skills in supply chain. MCP servers can read/write your codebase. Strategy: Systematic audit (5-min checklist)."

"Skills that fetch data from external URLs pose particular risk, as fetched content may contain malicious instructions. Even trustworthy Skills can be compromised if their external dependencies change over time."

"While you are working, you might notice unexpected changes that you didn't make. If this happens, STOP IMMEDIATELY and ask the user how they would like to proceed."

"NEVER use destructive commands like git reset --hard or git checkout -- unless specifically requested or approved by the user."

"Use gpt-5.4-mini when you want a faster, lower-cost option for lighter coding tasks or subagents."

"The gpt-5.3-codex-spark model is available in research preview for ChatGPT Pro subscribers and is optimized for near-instant, real-time coding iteration."

"If you're new to coding agents, start with the default permissions. Keep approval and sandboxing tight by default, then loosen permissions only for trusted repos or specific workflows once the need is clear."

"use /usage to check plan limits, /extra-usage to configure overflow billing, /config to configure settings."

"This performed well on the parts that matter for long-horizon work: following the spec, staying on task, running verification, and repairing failures as it went."

"I gave Codex a blank repo, full access, and one job: build a design tool from scratch. Then I let it run with GPT-5.3-Codex at 'Extra High' reasoning."

"All major workflows converge on the same architectural pattern: Research → Plan → Execute → Review → Ship."

"Agent teams: Automated coordination of multiple sessions with shared tasks, messaging, and a team lead. Beyond parallelizing work, multiple sessions enable quality-focused workflows."

"Git worktrees make this practical by enabling parallel, isolated agent sessions on the same repo."

"use context: fork to run a skill in an isolated subagent — main context only sees the final result, not intermediate tool calls. The agent field lets you set the subagent type."

"skills are folders, not files — use references/, scripts/, examples/ subdirectories for progressive disclosure."

"include scripts and libraries in skills so Claude composes rather than reconstructs boilerplate."

"Once a workflow becomes repeatable, stop relying on long prompts or repeated back-and-forth. Use a Skill to package the instructions in a SKILL.md file, context, and supporting logic Codex should apply consistently."

"Configure Codex for your real environment early. Many quality issues are really setup issues, like the wrong working directory, missing write access, wrong model defaults, or missing tools and connectors."

"Claude Code can generate 1.75x more logic errors than human-written code (ACM 2025). Every output must be verified. Use /insights commands and verify patterns through tests."

"OpenAI used Codex to build everything for DevDay 2025 — from Romain Huet's keynote demo… to the arcade machines… Even the Guardrails SDKs for Python and TypeScript were polished using Codex."

"Scheduled automations. Codex can run recurring tasks on a schedule without you prompting it. Daily issue triage. Weekly test coverage scans. Friday release notes."

"It's possible to ask the model at the end of a turn that didn't perform up to expectations how to improve its own instructions. The following prompt was used to produce some of the solutions to overthinking problems."

"always use thinking mode true (to see reasoning) and Output Style Explanatory (to see detailed output with &#9733; Insight boxes) in /config for better understanding of Claude's decisions."

"Common failure modes… Overthinking / long time before first useful action. Loggy / unnatural status updates instead of pair programmer collaboration. Awkward preamble phrasing and repetitive tics ('Good catch', 'Aha', 'Got it–')."

"use test time compute — separate context windows make results better; one agent can cause bugs and another (same model) can find them."

"Toggle the diff panel in the Codex app to directly review changes locally."

"Start with a minimal spec or prompt and ask Claude to interview you using AskUserQuestion tool, then make a new session to execute the spec."

"Multi-instance (multi-agent) orchestration workflow for deep research tasks. Breaks down research objectives into parallelizable sub-goals, runs child processes via codex exec, and aggregates results into polished reports."

"Interactive feature development workflow from idea to implementation. Creates requirements (EARS format), design documents, and implementation task lists. Triggered by: 'kiro' or references to .kiro/specs/ directory."

"Two skill patterns: agent skills (preloaded via skills: field) vs skills (invoked via Skill tool). See orchestration-workflow for implementation details of Command → Agent → Skill pattern."

"Check ~/.codex/log/codex-tui.log (or the most recent session-*.jsonl file if you enabled session logging) after a session if you need to audit which instruction files Codex loaded."

"Cisco — exploring Codex for engineering teams to accelerate feature development. Virgin Atlantic — deployed AI agents internally for data analysis and customer engagement. Duolingo — piloting Codex for development workflows."

"Production metrics from real companies: Fountain: 50% faster, CRED: 2x speed. 5 validated workflows (multi-layer review, parallel debugging, large-scale refactoring)."

"Delegate tasks to Claude Code directly from Slack channels. Tag @Claude with bug reports or feature requests for team workflows."

"Build AI Teams: Every major coding platform is converging on the same pattern — AI teammates that handle the mechanical work so engineers focus on the hard decisions."

"Use /review in the CLI to open Codex's review presets. The CLI launches a dedicated reviewer that reads the diff you select and reports prioritized, actionable findings without touching your working tree."

"have feature specific sub-agents (extra context) with skills (progressive disclosure) instead of general qa, backend engineer."

"Decision framework: Teams vs Multi-Instance vs Dual-Instance vs Beads."

"Type @ in the composer to open a fuzzy file search over the workspace root; press Tab or Enter to drop the highlighted path into your message."

"Press Enter while Codex is running to inject new instructions into the current turn, or press Tab to queue a follow-up prompt for the next turn."

"VS Code plan preview: auto-updates as Claude iterates, enables commenting only when the plan is ready for review, and keeps the preview open when rejecting so Claude can revise."

"Deliverables (write to /tests): TEST_PLAN.md – bullet list… Each role writes scoped artifacts in its own folder before handing control back to the project manager."

"Dual-Instance… use test time compute — separate context windows make results better; one agent can cause bugs and another (same model) can find them."

"Added the /claude-api skill for building applications with the Claude API and Anthropic SDK."

"Expose more writable roots with --add-dir (for example, codex --cd apps/frontend --add-dir ../backend --add-dir ../shared) when you need to coordinate changes across more than one project."

"If you want a long-lived environment, create a permanent worktree from the three-dot menu on a project in the sidebar. Permanent worktrees are not automatically deleted, and you can start multiple threads from the same worktree."

"You can also start threads on a worktree manually, and use Handoff to move a thread between Local and Worktree."

"Stats dashboard: Run /stats to see your usage patterns, favorite models, token counts, and streaks. Press Ctrl+S to copy for sharing."

"Claude Code inherits your shell, which means your tooling choices directly shape model behavior."

"Use /permissions inside an interactive session to switch modes as your comfort level changes."

"Production metrics from real companies (autonomous C compiler, 500K hours saved) 5 validated workflows… Fountain: 50% faster."

"MCP servers can read/write your codebase. Strategy: Systematic audit (5-min checklist). Community-vetted MCP Safe List. Vetting workflow documented."

"Added native MCP server management dialog — use /mcp in the chat panel to enable/disable servers, reconnect, and manage OAuth authentication without switching to the terminal."

"Because implicit matching depends on description, write descriptions with clear scope and boundaries."

"[!] 25.0% free (50.0K/200K) -> .claude/backups/3-backup-26th-Jan-2026-5-45pm.md … the statusline shows the backup path."

"Choose a reasoning level based on how hard the task is and test what works best for your workflow. Different users and tasks work best with different settings."

"Added spark icon in VS Code activity bar that lists all Claude Code sessions, with sessions opening as full editors. Added full markdown document view for plans."

"Rather than treating Claude as a chatbot, the core insight is this: Claude Code works best when treated like a junior engineer with tools, memory, and iteration — not a magic code generator."

"The developers and teams who understand this shift — who learn to orchestrate AI rather than just code alongside it — will thrive in this new landscape."

"Added a userpromptsubmit hook so prompts can be blocked or augmented before execution and before they enter history."