Guides
Step-by-step tutorials for AI coding tools. Hands-on walkthroughs tested on real production code.
GUIDE 2026-05-11
Accept or reject? Five heuristics that beat 'looks right'
Most AI-assisted coding mistakes aren't bad prompts — they're suggestions that looked right and weren't. Five concrete checks that catch the failures before they ship.
GUIDE 2026-05-11
Code ownership when half the code came from an AI
AI-generated code is generally not copyrightable—but once you accept a suggestion, you own it. Here's what that means legally, operationally, and when something breaks.
GUIDE 2026-05-11
AI as a code reviewer: where it helps, where it's noise
AI review tools catch real bugs consistently but miss architecture, intent, and taste. Here's how to use the pair-review workflow without letting AI comments become background noise.
GUIDE 2026-05-11
AI coding and git: commits, branches, and the etiquette of an AI co-author
How to structure commits, branches, and attribution when an AI agent shares your keyboard — and the one habit that prevents merge-conflict headaches.
GUIDE 2026-05-11
Training a junior engineer in a workflow that already includes AI
Most juniors in 2026 arrive with AI tools already in hand. The risk is they never build the foundations those tools are hiding. Here is a curriculum that uses AI without letting it become a crutch.
GUIDE 2026-05-11
AI coding and strong type systems: where TypeScript, Rust, and Haskell help
Strong type systems give AI a faster feedback loop than unit tests. Here's why TypeScript strict, Rust, and Haskell make AI more reliable—and where looser languages let mistakes slip through.
GUIDE 2026-05-11
AI-generated commit messages: the times they're great and the times they're bad
AI handles the mechanical parts of commit messages well. The part it misses is explaining why a change happened — and that gap matters more than most people expect.
GUIDE 2026-05-11
Secrets, sandboxes, and network isolation when using AI coding tools
Three threat axes in AI coding tools—log exfiltration, tool-call leaks, and supply-chain poisoning—and the mitigations that actually reduce risk.
GUIDE 2026-05-11
Token economics for AI coding: per-model cost curves and where they break your budget
A breakdown of 2026 token prices across Claude, GPT-5, and open source models — and where autonomous coding sessions actually spend the money.
GUIDE 2026-05-11
Context window compression: the techniques and what they cost
Long sessions, paste-heavy work, and verbose tool output push context windows to their limits. Here are three compression strategies, what fidelity each one sacrifices, and a workflow that sidesteps the problem entirely.
GUIDE 2026-05-11
The AI debugging loop: stop fixing symptoms
AI handles the mechanical steps of debugging well. Root cause analysis is the step it skips. Here's how to force it not to.
GUIDE 2026-05-11
AI coding hallucinations: the four shapes they take and how to spot them
AI coding tools hallucinate in four distinct patterns. Knowing which kind you're looking at determines whether the toolchain catches it or a human must.
GUIDE 2026-05-11
AI coding in CI/CD: the few places it earns its keep
Most AI-in-CI integrations create noise faster than they create signal. PR triage works. Auto-review mostly doesn't. Here's where the tradeoffs land in practice.
GUIDE 2026-05-11
A decision framework for which AI model to use on which task
Most developers default to the most expensive model for every task. A four-axis framework—cost, intelligence, speed, context—shows when that's right and when it's 10x overpay.
GUIDE 2026-05-11
Pair programming with AI: three patterns, three failure modes
Three pair-programming patterns for working with AI—junior dev, rubber duck, second senior—and the one to avoid: letting the model lead.
GUIDE 2026-05-11
Spike mode vs production mode: two AI coding velocities for two purposes
AI coding tools are fast in both directions. The problem is that fast exploration and fast shipping require completely different operating modes—and conflating them is how spike code ends up in production.
GUIDE 2026-05-11
Where AI coding tools stop helping on legacy code
AI tools thrive on greenfield work. On legacy code with custom DSLs, undocumented invariants, and decade-old conventions, the instinct to modernize becomes a liability.
GUIDE 2026-05-11
Should the AI write the test, the implementation, or both? Three patterns
When AI handles tests and implementation together, it can satisfy itself without testing real behavior. Here's how to assign the work to get actual coverage.
GUIDE 2026-05-11
Aider chat history compression: keeping long sessions affordable
Every Aider turn re-sends the full chat history. After 30+ turns that history can cost more than the code change itself. Here is how to control it.
GUIDE 2026-05-11
Aider voice mode: dictating prompts when typing is the bottleneck
Aider's voice mode lets you speak prompts instead of typing them, using Whisper for transcription. Here's when it speeds up the loop and when it quietly wrecks it.
GUIDE 2026-05-11
Aider's --weak-model: the second model that pays for itself
Aider uses a cheap secondary model for commit messages, summaries, and name suggestions. Here's what that flag does, when it helps, and when to turn it off.
GUIDE 2026-05-11
What 1M context on Opus 4.7 actually buys you (and what it doesn't)
Opus 4.7's 1M-token context window is genuinely useful for large cross-file refactors and multi-document synthesis — but most tasks don't need it, and paying for it blindly is expensive.
GUIDE 2026-05-11
Anthropic's official skill pack: PDF, XLSX, DOCX, PPTX and where they shine
The anthropic-skills pack ships eight skills with Claude Code. Four handle documents. This is what triggers each one, where each earns its keep, and where you should reach for something else.
GUIDE 2026-05-11
Using the brainstorming skill to turn a half-baked idea into a written spec
The brainstorming skill forces a design-first workflow in Claude Code: one question at a time, proposals with tradeoffs, and a committed spec before any code runs.
GUIDE 2026-05-11
A custom MCP server in 60 lines: the minimum viable shape
Build a focused MCP server from scratch using the TypeScript SDK. Covers protocol basics, a real git-log-search example, wiring into Claude Code, and the iteration loop that makes debugging fast.
GUIDE 2026-05-11
Choosing between Opus, Sonnet, and Haiku in Claude Code without overspending
Opus costs roughly 5x Sonnet and 20x Haiku. Routing tasks to the right model is the single highest-leverage cost decision in a Claude Code workflow.
GUIDE 2026-05-11
The systematic-debugging skill: when the agent keeps proposing the wrong fix
Claude Code's default failure mode is guessing at symptoms. The systematic-debugging skill enforces root-cause-first debugging: no fix until the cause is identified.
GUIDE 2026-05-11
Fast mode in Claude Code: when to trade Opus 4.7 for Opus 4.6 speed
Claude Code's /fast toggle switches to Opus 4.6 mid-session. Here's which tasks benefit from the faster model and which ones warrant staying on 4.7.
GUIDE 2026-05-11
Claude Code from zero: installing the CLI and getting through the first useful session
Step-by-step install, first-run auth, and a concrete starting prompt — plus the five mistakes that make beginners give up on Claude Code before it clicks.
GUIDE 2026-05-11
PostToolUse hooks: the after-the-fact watchdog pattern
PostToolUse fires after every Claude Code tool call and can inject context, run formatters, and build audit trails — without blocking the agent mid-task.
GUIDE 2026-05-11
SessionStart hooks: injecting context the model would otherwise miss
SessionStart fires once before any tool calls, letting you inject real-time context—git state, sprint focus, oncall rotation—directly into the model's system prompt for that session.
GUIDE 2026-05-11
Claude Code hooks: where they fire, what they can read, and what they can't
Claude Code hooks run shell commands at deterministic lifecycle points. This guide covers all five events, the JSON contracts each one uses, and which hooks can block versus only observe.
GUIDE 2026-05-11
Claude Code in VS Code and JetBrains: when the IDE extension wins and when the terminal does
Claude Code runs both as a terminal CLI and as IDE extensions for VS Code and JetBrains. The experience differs in ways that matter: here's which surface to use and when.
GUIDE 2026-05-11
Claude Code in a monorepo: directory roots, CLAUDE.md, and not getting lost across packages
Starting Claude Code at the wrong directory in a monorepo costs you context. Here's how to manage session roots, per-package CLAUDE.md files, and cross-package edits without losing your mind.
GUIDE 2026-05-11
MCP on Claude Code: from `mcp__` tool names to a working connection
MCP connects Claude Code to external tools without bundling everything into the agent. Here's how to configure servers, understand the tool-naming convention, and debug a server that won't show up.
GUIDE 2026-05-11
Three MCP servers worth installing: Postgres, Notion, and Linear
Postgres, Notion, and Linear MCP servers extend Claude Code with live data access. Each has a clear use case and a specific gotcha that bites you if you skip the setup details.
GUIDE 2026-05-11
MCP tools and Claude Code's tool-use loop: how they actually compose
Native tools and MCP tools look identical to the model. Understanding the lifecycle differences—and what happens when the tool list grows too large—makes MCP integrations reliable.
GUIDE 2026-05-11
Output token budgets in Claude Code: avoiding the truncation surprise
Claude Code's output token ceiling—not your context window—is what cuts long generations short. Here's how to spot truncation early and structure requests to stay under the limit.
GUIDE 2026-05-11
Claude Code permission modes: plan, edit, and auto-accept — and when to switch
Claude Code's three permission modes gate different levels of agent autonomy. Getting the mode wrong costs you either hours of unnecessary round-trips or a destructive operation you can't undo.
GUIDE 2026-05-11
Plan mode in Claude Code: the conversation step that prevents thrash
Claude Code's plan mode produces a written proposal with no file edits or commands. Here's when to use it, how to refine plans through dialogue, and when to skip it.
GUIDE 2026-05-11
Claude Code plugins vs skills: the same thing or two different things?
Plugin and skill are related but not interchangeable. A plugin is the installable package; a skill is the unit of behavior inside it. Getting the distinction right changes how you build, version, and share reusable workflows.
GUIDE 2026-05-11
Prompt caching on Claude Code: the 5-minute TTL and how to actually save money
Claude Code's prompt caching has a 5-minute TTL. Understanding that clock shapes how you structure sessions and which habits quietly drain your budget.
GUIDE 2026-05-11
Resuming Claude Code sessions without re-explaining the entire task
Claude Code stores conversation history locally. Here's how to resume sessions with --continue and session IDs, when it works well, when it doesn't, and one habit that makes re-entry fast.
GUIDE 2026-05-11
How Claude Code decides which skill to invoke (and how to influence that)
Claude Code's orchestrator routes tasks to skills by reading their descriptions. Here's exactly how that matching works, why competing descriptions cause routing failures, and how to fix them.
GUIDE 2026-05-11
Tuning a Claude Code skill's frontmatter: getting the description right
Claude Code reads a skill's description field to decide when to invoke it. A vague description means the skill never triggers; an overly broad one fires on everything. Here's how to write one that routes correctly.
GUIDE 2026-05-11
Skill or hook? Two extension points and how to choose
Claude Code has two extension points: skills run inside the model's loop, hooks run in the harness around it. Knowing which to reach for determines whether your automation is reliable or just suggestive.
GUIDE 2026-05-11
Skill or MCP server? Where the boundary actually is
Skills shape how Claude Code thinks and works. MCP servers give it new tools to call. Confusing the two leads to building the wrong thing.
GUIDE 2026-05-11
Claude Code skills: why they exist when prompt templates already worked
Claude Code skills are dynamically loaded behavior packages — only invoked when relevant. Here's why that matters and how the distribution model actually works.
GUIDE 2026-05-11
Slash commands and keybindings: the parts of Claude Code most people don't customize
Claude Code's built-in slash commands, user-defined skill triggers, and keybindings.json are all configurable — most users never touch them.
GUIDE 2026-05-11
Claude Code streaming output: what it costs and what it buys you
Claude Code streams tokens as they're generated, so you see output in under a second instead of waiting 30 seconds for silence. Here's when that trade is worth it and when it isn't.
GUIDE 2026-05-11
Claude Code subagents: when to dispatch and when to keep the main session
Subagents give Claude Code an isolated context window for grunt work. Here's when that matters, when parallel dispatch pays off, and when it backfires.
GUIDE 2026-05-11
The Superpowers skill suite: what it covers and what it deliberately doesn't
Superpowers is a community skill pack for Claude Code that enforces a consistent workflow: brainstorm, plan, execute, review. Here's what each skill does and where the suite draws its own boundary.
GUIDE 2026-05-11
The test-driven-development skill: TDD as a tool-use discipline
Claude Code skips the failing-test step without enforcement. The TDD skill closes that gap by requiring a visible failing run before implementation is allowed to start.
GUIDE 2026-05-11
Building a team-shared skill library that doesn't decay in six months
A git-tracked shared skill library prevents duplicate work and knowledge loss when engineers leave. This guide covers repo structure, naming conventions, deprecation process, and CLAUDE.md as a skill index.
GUIDE 2026-05-11
Extended thinking on Claude Code: where the extra tokens earn their keep
Extended thinking lets Claude reason silently before answering — useful for hard problems, wasteful on simple ones. Here's how to tell the difference and read the trace when things go sideways.
GUIDE 2026-05-11
verification-before-completion: stop claiming work is done when it isn't
Claude Code's verification-before-completion skill enforces a simple rule: every 'done' claim must be backed by real output. No test runs summarized from memory. No lint passes assumed.
GUIDE 2026-05-11
Claude Code vs Cursor: same task, two tools, what actually differs
Run the same multi-file refactor through both tools and the ergonomic gap becomes concrete: Cursor wins on inline completion flow; Claude Code wins on coordinated multi-file changes. The real question is where each fits in your day.
GUIDE 2026-05-11
Writing your first Claude Code skill: from idea to triggered execution
Claude Code skills let you encode repeatable workflows as prompt-driven commands. This guide walks through writing a real skill end to end—frontmatter, body, install, and debugging.
GUIDE 2026-05-11
Pairing writing-plans and executing-plans: the spec-to-merge pipeline
How to use Claude Code's writing-plans and executing-plans skills together — from a vague spec to a checkboxed plan with exact file paths, complete code, and a clean execution run.
GUIDE 2026-05-11
Cline auto-approve: what to enable and what not to
Cline's per-category auto-approve settings can eliminate constant confirmation clicks, but each category has a different blast radius. Here's how to set boundaries that speed things up without creating cleanup work.
GUIDE 2026-05-11
Cline's Computer Use: closing the loop on UI changes
Cline's Computer Use feature lets the agent drive a real browser to verify its own UI edits. Here's what it does well, what it breaks on, and when the round-trip cost isn't worth it.
GUIDE 2026-05-11
Cline checkpoints: the undo button that's better than git reset
Cline auto-creates checkpoints between major steps of a task. Roll back to any of them without unwinding your git history or restarting from scratch.
GUIDE 2026-05-11
Cline task history: replaying past tasks without doing them by hand
Cline stores every completed task on disk. Here is how to re-open past tasks, replay them against new branches, use them as model-version smoke tests, and what to purge before that history becomes a liability.
GUIDE 2026-05-11
Codex CLI from zero: installing, authenticating, and the first useful loop
Codex CLI is OpenAI's official AI coding agent for the terminal. This guide covers both install paths, the two auth modes, and the sandboxed shell that makes it safer than it looks by default.
GUIDE 2026-05-11
Codex review mode: a second opinion that doesn't agree with you for free
Codex CLI can review a diff or file and return categorized findings before a human ever sees your PR. Here's how to use it, what to trust, and what to ignore.
GUIDE 2026-05-11
Codex in GitHub Actions: running an autonomous agent on pull requests without losing control
How to install Codex in a GitHub Actions runner, auth safely, scope the agent to one branch, cap per-run costs, and recover when the agent misbehaves.
GUIDE 2026-05-11
Codex vs Claude Code: same job, different model families — concrete differences
Both run in your terminal, read your codebase, and execute autonomous tasks. What's different is how GPT-family and Claude-family models approach the same problem — and those differences are visible and reproducible.
GUIDE 2026-05-11
Codex reasoning effort: how the low/medium/high knob actually changes behavior
Codex's reasoning_effort parameter changes how much the model thinks before responding. Here is how to read the tradeoffs and pick the right level for the task at hand.
GUIDE 2026-05-11
Copilot Edits multi-file preview: the diff view most reviewers miss
Copilot Edits shows a unified diff across every file before you apply. Most users skip straight to Apply All and miss the selective-accept workflow that makes multi-file edits actually safe.
GUIDE 2026-05-11
Cursor Composer multi-file prompting: getting the right edits across the right files
Composer operates across files simultaneously; getting useful diffs requires deliberate file selection, precise @-references, and a followup loop for the parts that miss.
GUIDE 2026-05-11
Cursor Notepad: the workspace memory feature people forget exists
Cursor Notepad lets you store reusable text—project conventions, prompt templates, design decisions—inside the editor and reference it from chat with @Notepad. Most people never find it.
GUIDE 2026-05-11
Cursor plus Claude Code plus Aider: when running multiple AI tools at once pays off
Most days one AI coding tool is enough. This is about the narrower case where running three in parallel — each doing the thing it was built for — actually earns its cognitive overhead.
GUIDE 2026-05-11
The hidden cost of switching AI coding tools every quarter
Switching AI coding tools costs more than a license fee. Muscle memory, rules files, MCP configs, and team norms all reset with every switch — here is how to evaluate whether the cost is worth paying.
GUIDE 2026-05-11
.windsurfrules and Cascade memory: Windsurf's behavior controls
Windsurf has two separate behavior controls: .windsurfrules persists across every session forever, while Cascade memory only lasts for the current session. Mixing them up causes subtle, confusing drift.
GUIDE 2026-05-11
Zed's inline assistant: the keystroke-driven AI flow
Zed's inline assistant turns selected code into context with one chord and a plain-English prompt — no panel switching, no pasting. Here's how it works and when to use it.
GUIDE 2026-05-11
Zed multi-cursors plus AI: the pattern Cursor can't match
Zed lets you place cursors at dozens of callsites simultaneously, then invoke the inline AI assistant to transform each one with local context — a mechanical refactor pattern that Cursor's agent loop can't replicate.
GUIDE 2026-05-05
Aider for incremental refactoring: a terminal workflow that actually scales
Aider's git-native approach makes it better than IDE-based tools for large refactors that span dozens of files. Here's the workflow I use.
GUIDE 2026-05-04
Running local models in Cline with Ollama: when it's worth the trouble
Cline supports Ollama as a model provider, which means a fully offline coding agent on your laptop. The setup is straightforward. The quality gap is large. Here's how to think about both.
GUIDE 2026-05-02
Aider's CONVENTIONS.md: keeping the model on script across a session
A single CONVENTIONS.md file in your repo, loaded into every Aider session, drops the rate of style-mismatch fixes from common to rare. Here's what to put in it.
GUIDE 2026-05-01
Pair programming in Zed: real-time collaboration with AI assistance for both seats
Zed's Channels feature lets two engineers share an editor in real time with shared AI context. The setup is straightforward; the social patterns take some getting used to.
GUIDE 2026-04-28
Aider's architect mode: when the slower, more expensive workflow is worth it
Architect mode runs two model calls per turn: a strong model plans, a cheaper model edits. The math works for some tasks and not others. Here's the decision rule.
GUIDE 2026-04-27
Cursor rules for projects with multiple stacks: per-directory .cursorrules
Cursor reads .cursorrules from the project root by default. For repos with a TypeScript frontend and a Python backend, that's the wrong granularity. Here's how to scope rules per directory.
GUIDE 2026-04-26
Zed extensions are different from VS Code extensions, and that matters more than you'd think
Zed extensions run in WebAssembly, can't access the network freely, and are written in Rust. The constraint produces a different ecosystem and a different set of tradeoffs.
GUIDE 2026-04-25
Cursor Rules: making the AI follow your project's actual conventions
Cursor will write code in the average style of its training data. Cursor Rules let you override that with your project's specific conventions, framework choices, and naming standards.
GUIDE 2026-04-25
GitHub Copilot for PR review: a workflow that actually catches things
Copilot's auto-review feature misses real bugs and flags style nits. Here's a three-pass workflow that uses Copilot for what it's good at and humans for what it isn't.
GUIDE 2026-04-23
Windsurf and TypeScript strict mode: making Cascade respect your tsconfig
Windsurf's Cascade defaults assume loose TypeScript. With strict mode on, you'll get type errors on roughly half of suggestions unless you adjust the model context.
GUIDE 2026-04-22
Setting up Cline with Claude, GPT-4o, and OpenRouter as fallback providers
Cline lets you wire up multiple model providers and route between them. Here's the config that survived a month of real use, including the OpenRouter fallback that saved a deadline.
GUIDE 2026-04-21
Aider in a monorepo: scoping context to one package without losing the cross-package picture
Aider's --subtree-only flag is necessary but not sufficient. Here's the four-file pattern for keeping aider focused on one package while still letting it see shared types.
GUIDE 2026-04-20
AI-assisted debugging: a methodology that beats vibes-based prompting
Asking the AI 'why is this broken' produces plausible-but-wrong answers. A four-step structure produces useful ones. Here's the structure and what each step actually does.
GUIDE 2026-04-18
Cursor's codebase indexing on a 1M-line repo: tuning .cursorignore and what to expect
Cursor's indexing scales surprisingly well, but a 1M-line repo will hit limits without tuning. Here's the configuration that makes it usable.
GUIDE 2026-04-16
Aider with pre-commit hooks: making the linter the model's feedback loop
Aider's auto-commit feature can run pre-commit hooks. Configured well, this means the linter rejects bad suggestions before they reach your branch. Configured badly, it loops forever.
GUIDE 2026-04-11
GitHub Copilot Enterprise data residency: what's actually committed in writing
Copilot Enterprise's data residency story is more nuanced than the marketing pages suggest. Here's what GitHub commits to in the contract versus what they hint at on the website.
GUIDE 2026-04-10
Windsurf for full-stack work: keeping the frontend and backend in one Cascade session
Most AI tooling guides treat frontend and backend as separate sessions. Windsurf's Cascade can hold both in one context. Here's why that matters and how to set it up.
GUIDE 2026-04-08
Using AI tools for legacy code archaeology: explaining what 2014-vintage code does
Inheriting a 10-year-old codebase is its own kind of work. AI tools won't fix the legacy, but they can dramatically speed up the understanding-what-this-does phase.
GUIDE 2026-04-08
Windsurf Cascade for multi-step tasks: keeping the agent on track over 30 minutes
Cascade can run autonomous tasks for half an hour. The reliability comes from prompt structure, not luck. Here's the structure that keeps it from drifting.
GUIDE 2026-04-06
Setting up Cursor-equivalent AI in JetBrains IDEs (IntelliJ, GoLand, PyCharm)
Cursor doesn't have a JetBrains version. Here are the actual options for getting comparable AI capabilities in IntelliJ, GoLand, or PyCharm — with the tradeoffs each one has.
GUIDE 2026-04-06
Cursor's BugBot for PR review: where it earns its $40/month and where it doesn't
Cursor BugBot reviews PRs automatically. The hit rate on real bugs is real but uneven. Here's where it justifies the cost.
GUIDE 2026-04-05
TDD with aider: writing the test first and letting the model fill in the implementation
Aider's edit format is well-suited to test-driven development. Write the failing test, ask aider to make it pass, review the diff. The structure produces better code than letting aider write both.
GUIDE 2026-04-02
Pair programming with AI: a structured approach that beats free-form chat
Free-form prompting feels like pair programming and often isn't. A four-role structure produces better outcomes and is closer to how human pairing actually works.
GUIDE 2026-04-02
Cursor YOLO mode: when 'auto-accept everything' is reasonable, and when it's not
Cursor's YOLO mode auto-accepts the agent's edits and runs commands without prompting. It's not as reckless as the name suggests, if you set up the safety net first.
GUIDE 2026-03-31
Setting cost budgets for Cline: monthly limits, alerts, and what to do when you hit them
Cline can burn through API credits faster than expected. Anthropic's spend limits, Cline's per-task budget, and OpenRouter's usage caps each fail in different ways. Here's the configuration that actually contains spend.
GUIDE 2026-03-29
Cline for Terraform and infrastructure-as-code: high leverage with one big caveat
Terraform is repetitive, well-documented, and pattern-heavy — exactly the kind of work AI tools handle well. The caveat is that the cost of a wrong terraform apply is unusual.
GUIDE 2026-03-25
Integrating AI into your PR review workflow without making review worse
AI-generated PR reviews can catch real issues or flood your team with low-signal noise. The difference is in what you ask the AI to do and how you wire it into the human review.
GUIDE 2026-03-22
AI-assisted SQL: when it speeds you up and when it'll break your data
AI tools write plausible SQL fast. Plausible SQL is occasionally correct, often subtly wrong, and dangerous when the wrong query touches production. Here's how to use AI for SQL safely.
GUIDE 2026-03-08
GitHub Copilot Knowledge Bases: getting your team's docs into the model
Knowledge Bases let Copilot ground answers in your team's docs. Setup is easy; the real questions are about what content to include and how to keep it current.
GUIDE 2026-03-06
Using Cursor keyboard-only: bindings that get you off the mouse
Cursor's defaults assume mouse interaction in several places. Customizing 12 keybindings produces a fully keyboard-driven workflow.
GUIDE 2026-03-03
Zed's multibuffers for cross-file refactoring: an underused power feature
Multibuffers let you edit selections from many files in one buffer. Combined with Zed's AI, this is a powerful refactoring primitive that few users discover.
GUIDE 2026-01-31
Debugging Cursor's wrong suggestions: a checklist for when the model is being weird
When Cursor's suggestions are off, the cause is usually one of six things. Here's the checklist that gets you back on track.
GUIDE 2026-01-13
Aider with Makefile-driven projects: integrating with non-standard build flows
Aider's auto-test feature wraps any shell command. For projects with custom Makefile-driven builds, the integration is straightforward but has gotchas.
GUIDE 2025-12-29
Cursor with Storybook: generating stories that match your component patterns
Storybook stories are repetitive but high-value. Cursor handles them well with the right setup.
GUIDE 2025-12-26
GitHub Copilot Extensions: when third-party integrations are worth it
Copilot Extensions add capabilities through external services. Some are useful; many add more friction than value.
