Tip library
Curated AI workflow tips
Short, practical nudges connected to AIErudit courses and real AI delivery workflows.
Customize Your Claude Code Status Line
AIErudit angle: A custom status line turns silent, easy-to-ignore signals — model, git branch, diff stats, session cost, and context-window usage — into an always-on cockpit, so you catch runaway spend or a filling context before they bite. Wiring one script into settings.json is a practical exercise in making an AI coding session observable and auditable.
Undo Claude's Changes Instantly with Rewind Checkpoints
AIErudit angle: When an agent takes a wrong turn, the recovery skill that separates confident operators from stuck ones is knowing you can rewind to any prior checkpoint in seconds. Claude Code auto-snapshots before every prompt, so you can revert code, conversation, or both without fear — a core habit for iterating boldly on AI-generated work.
Track Token Usage with the /context Command
AIErudit angle: Context is the scarce resource every AI delivery workflow silently spends — system prompt, tools, MCP servers, agents, memory, and messages all compete for the same 200k window. Running /context to see the per-category breakdown is how you diagnose why an agent slows or forgets, and decide what to prune, compact, or restart.
Get 2.5x Faster Responses with Fast Mode
AIErudit angle: Fast mode is a speed-for-cost lever, not a quality tradeoff — the same Opus model, up to 2.5x faster tokens, at a higher per-token price billed to usage credits on subscription plans. Knowing when to pull it (live debugging, rapid iteration, deadlines) versus leave it off (long autonomous runs, batch, CI) is a practical cost-versus-latency decision every AI operator should own.
Create Reusable Commands with Skills
AIErudit angle: The instructions you copy-paste into every session are latent process — a Skill turns them into a repeatable slash command that runs the same steps, in the same order, with the same output every time. Authoring a SKILL.md is the entry point to standardizing your AI delivery workflows without losing the ability to intervene mid-run.
The 6 Claude Code Extension Points, Untangled
AIErudit angle: Skills, Hooks, MCP, Sub-agents, Agent Teams, and Plugins solve genuinely different problems, and picking the wrong one is a common source of over-engineered AI setups. This mental model — each mechanism answers one question (what to do, what to access, who works, when to automate, how to share) — lets you reach for the right extension point on purpose.
Run Shell Commands Without Leaving Claude Code
AIErudit angle: Bash mode collapses the constant tab-switching that fragments an AI session — prefix any command with ! and it runs in your shell while the output lands back in Claude's context. Keeping the loop of run, observe, and ask in one place is a small delivery habit that compounds across a debugging session.
Master Claude Code Permissions: Deny Rules, Modes & Wildcards
AIErudit angle: Permissions are the access-control layer that keeps an autonomous agent from touching what it shouldn't — and three concepts govern most of it: deny always wins, modes change everything, and Tool(specifier) syntax supports wildcards and gitignore patterns. Getting the evaluation order and the misunderstood dontAsk mode right is basic operational security for AI-driven work.
Adjust Claude's Effort Level on the Fly
AIErudit angle: Matching reasoning depth to task complexity is a core AI-delivery cost skill. This tip shows how to dial Claude's effort level up for architecture work and down for renames and formatting, so you spend thinking tokens only where they change the outcome. Configure it interactively, per-project, or in CI to keep quality high and cost predictable.
Connect Claude to Your Tools with MCP
AIErudit angle: MCP is how you extend an AI agent's reach into the real tools your delivery runs on — Notion, GitHub, databases — without writing glue code. This tip shows the two-minute setup for remote (HTTP) and local (stdio) servers and the scoping rules that decide who on your team gets the connector. Knowing MCP turns Claude from a chat assistant into an agent wired into your stack.
Watch Claude Think in Real Time with Verbose Mode
AIErudit angle: Reviewing an agent's reasoning as it happens is the fastest way to catch hallucinations and wrong assumptions before they become code. This tip shows how Ctrl+O surfaces Claude's live thinking trace so you become a real-time reviewer and can interrupt a bad path with Ctrl+C before tokens are wasted. It is a core supervision skill for anyone shipping AI-generated work.
Let Claude Open Chrome and Debug Your Frontend
AIErudit angle: Closing the loop between an agent and the running app is what turns AI from a code generator into a tester that verifies its own work. This tip shows how claude --chrome lets Claude open tabs, fill forms, read console errors, and confirm UI behavior against the real DOM and your login state. It is a practical delivery skill for shipping frontends with fewer manual QA cycles.
Fork Your Claude Conversations to Explore Safely
AIErudit angle: Branching a conversation lets you explore multiple AI approaches to the same problem without losing progress — git checkout -b for your session. This tip shows how --fork-session copies full history into an independent session so you can try a risky fix and fall back cleanly if it fails. It is a context-management skill that keeps exploratory AI work reversible.
Run Multiple Claudes in Parallel with Git Worktrees
AIErudit angle: Parallelizing AI work across isolated branches is how you scale delivery throughput without merge chaos. This tip shows how claude -w creates a git worktree, branch, and Claude session in one command, so three terminals can drive three tasks on the same repo with zero conflicts. It is a foundational orchestration skill for running an AI team of one.
Automate Skill Permissions with allowed-tools
AIErudit angle: Granting an agent exactly the tools it needs — and nothing more — is the balance between friction and safety in production AI workflows. This tip shows how the allowed-tools frontmatter field pre-approves specific tools and Bash/MCP patterns so a multi-tool skill runs without dozens of prompts while unlisted actions still require approval. It is a governance skill for shipping trustworthy automations.
Automate Your Workflow with Claude Code Hooks
AIErudit angle: Hooks make AI-assisted workflows deterministic — unlike CLAUDE.md guidance the model can ignore, a hook always fires when its condition is met. This tip shows the three handler types (command, prompt, agent) and lifecycle events so you can auto-format, block destructive commands, and enforce test coverage without relying on the model's goodwill. It is a delivery-reliability skill for productionizing agents.
Four Agentic AI Patterns You Already Use in Claude Code
AIErudit angle: Anthropic's five agent workflow patterns aren't theory — they're the architecture decisions you make every time you design an AI delivery workflow. This tip maps each pattern (prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer) to a concrete Claude Code primitive so you pick the right building block on purpose. Knowing the map turns ad-hoc prompting into repeatable, reviewable delivery.
The Evaluator-Optimizer Pattern That Keeps AI Output Honest
AIErudit angle: Trustworthy AI delivery means every claim gets checked against real evidence — source code, docs, config — not the model's confidence. This tip shows how to build an evaluator-optimizer as an on-demand inline skill that audits the previous output and assigns evidence-backed verdicts. It's the discipline that catches silent drift between a plan and what actually shipped.
Five Claude Code Desktop Features Worth Leaving the Terminal For
AIErudit angle: Not every AI-delivery contributor lives in the terminal — PMs and technically capable non-coders need a lower-friction on-ramp to the same engine. This tip covers five Desktop-exclusive capabilities (visual diff review, automatic worktree sessions, embedded app preview, PR auto-fix/auto-merge, graphical connectors) that make AI work reviewable and collaborative. It helps you route the right people to the right interface.
When Claude Code Loads Each Feature and What It Costs
AIErudit angle: Efficient AI delivery starts before your first prompt — knowing which features consume context at session start versus on-demand versus never. This tip breaks down the three loading phases so you design a setup that saves tokens instead of burning them. It turns context budgeting into a deliberate configuration choice.
Pick the Right Model in Claude Code to Stop Wasting Tokens
AIErudit angle: Cost-aware AI delivery means allocating reasoning power where it actually matters instead of defaulting to the frontier model for everything. This tip shows the plan-execute-explore strategy — Opus for architecture, Sonnet for implementation, Haiku for search — and the opusplan alias that automates it. It's a direct lever on your AI spend and latency.
Fix a CLAUDE.md That's Full of Junk
AIErudit angle: A CLAUDE.md is the shared context contract for your whole AI-delivery team, and every auto-inferrable line dilutes the instructions that matter. This tip gives the rule — document the why, not the what — and a setup flow to strip redundancy and keep only what Claude can't discover from the code. A lean CLAUDE.md saves context on every session and keeps guidance sharp.
How Claude Code Remembers Between Conversations
AIErudit angle: Durable AI delivery compounds when your assistant carries forward build quirks, debugging patterns, and architecture decisions across sessions instead of relearning them each time. This tip explains auto memory — the file-based system that writes and reads project notes in ~/.claude/projects/<project>/memory/ — and how to inspect, edit, and disable it. Owning that memory file turns one-off explanations into persistent team context.
Run Claude Code as an Autonomous Headless Agent
AIErudit angle: Scaling AI delivery means running agents unattended — in CI, scripts, or cron — with hard guardrails on what they can touch and spend. This tip shows how the -p flag turns Claude Code into a reasoning headless agent, and how --allowedTools, --max-turns, and --max-budget-usd keep autonomous runs safe and bounded. It's the pattern behind scheduled log reviews, health checks, and overnight triage.
Get Notified When Claude Code Finishes — Only When You Look Away
AIErudit angle: Long agent runs are wasted if you sit and watch the spinner. A Stop hook that plays a sound only when your terminal is not in focus lets you fire off a task and go do product work, returning only when the agent is actually done — the core discipline of async AI delivery.
Turn Your Whole Session Into a Specialized Agent with --agent
AIErudit angle: Reusable, role-scoped agents are how teams standardize AI work — a reviewer, a debugger, a deployer, each with its own prompt, tool allowlist, and model. Defining agents as versioned Markdown files turns tribal prompting habits into shareable delivery infrastructure.
Ask Side Questions Mid-Task Without Breaking Flow Using /btw
AIErudit angle: Context hygiene is a delivery skill — every stray question you inject pollutes the working conversation and costs precision. /btw answers quick lookups from existing context in a disposable overlay, so the agent keeps working and your main thread stays clean and cheap.
1M Tokens of Context — and Why You Shouldn't Fill Them
AIErudit angle: More context is not more capability — model recall degrades with distant tokens (context drift), so filling a 1M window quietly erodes quality. Monitoring with /context and compacting proactively is a core cost-and-quality discipline for long AI delivery sessions.
Control a Running Claude Code Session From Your Phone
AIErudit angle: Async, mobile-driven agent work multiplies delivery throughput — kick off a task at your desk and keep steering it from anywhere. Remote Control keeps the process local (outbound HTTPS only, no open ports) while your phone acts as a window, so you supervise long runs without being chained to the terminal.
Drive Claude Code From Telegram or Discord With Channels
AIErudit angle: Channels turns any chat app into a secure command line for your agent — text a task, it runs with full tools and replies in the same thread. A sender allowlist plus pairing code keeps this powerful async delivery surface locked to you, which matters as chat-driven ops become a real attack surface.
Claude Code Plugins Are Just Your .claude Directory, Packaged
AIErudit angle: A plugin is no new technology — it is your skills, agents, hooks, and MCP config bundled into a shareable, versioned package. Packaging your AI workflows this way is how a team turns one person's setup into repeatable delivery infrastructure everyone installs with one command.
Tell Your Claude Code Sessions Apart With /rename and /color
AIErudit angle: Running parallel agents is a delivery multiplier only if you can tell them apart. Naming sessions with /rename and tagging them with /color gives each a visual identity and makes /resume a searchable index instead of a memory test — basic hygiene for anyone orchestrating multiple AI workstreams.
Code by Voice: Dictation Mode in Claude Code
AIErudit angle: Dictating prompts instead of typing them lets you describe intent faster and keep your hands free to browse code or docs while you steer the agent. Streaming transcription tuned for dev vocabulary (regex, OAuth, JSON) turns spoken intent into a ready prompt, and you can mix voice with typed text in the same message.
Why Your Sub-Agents Return Incomplete Results
AIErudit angle: Sub-agents start with zero context and only see the query the orchestrator writes, so delegation quality is a product skill: ship the why, not just the what. Include the objective in the delegation, preload context with skills, and ask focused follow-ups so the same sub-agent resumes without losing the thread.
Make Claude Code Watch Your Code While You Work
AIErudit angle: /loop runs a prompt on a recurring interval inside your live session, so each iteration keeps full context of the files you changed and decisions you made. It's a context-aware watchdog for delivery work like deploys, PR comments, and log errors, versus a blind cron that starts fresh every run.
Claude Code's Hidden Interactive Tutorial: /powerup
AIErudit angle: /powerup is an in-terminal set of 18 interactive lessons that surface features most people miss, turning idle downtime into hands-on capability building. Even power users discover things like backgrounding a bash command with a trailing & or cycling modes with Shift+Tab.