Topic
Tutorials, tips, and deep dives on Anthropic's agentic coding CLI.
283 resources - 161 posts, 4 tools, 118 guides

A companion guide to the Nimbalyst video: an open-source visual workspace that runs Codex and Claude Code from your existing subscriptions, with a Kanban board, a planning workflow, and AI commits. Here is what it does and where it fits.

A developer reverse-engineered Claude Code and found hidden markers that classify users by timezone, domain, and API keywords - using unicode apostrophe swaps and date format changes.

A developer fed 266MB of DICOM MRI data to Claude Code Opus for a second opinion on a shoulder diagnosis. The AI disagreed with the doctor. HN radiologists weighed in.

Grok Build is xAI's agentic CLI with 8 parallel subagents, a plan-first workflow, and Arena Mode for competing outputs. Installation, pricing, real commands, and how it compares to Claude Code and Codex.

Claude outages and 529 overloads expose whether your AI coding workflow has checkpoints, receipts, model-switch paths, and small enough task slices to survive provider degradation.

A GitHub-trending library of Anthropic cybersecurity skills points at the next agent security layer: framework-mapped playbooks that need provenance, tests, and abuse boundaries before they become trusted runtime tools.

A new layer is forming around Claude Code, Codex, Copilot CLI, and local memory tools: the local coding agent workspace. It is not the model. It is the bench where agents get supervised.

OpenMontage is trending because it treats video production like a repo-shaped agent workflow: scripts, assets, render pipelines, review loops, and coding agents working across the whole process.

A developer discovered that Claude Code's thinking output is summarized, not the raw reasoning. Here's what Anthropic's docs actually say - and why it matters.

Goal, loop, routine. Three verbs, two tools, one hard part. A complete field guide to running agentic loops in Claude Code and Codex, the real commands, the patterns people actually run, and the two failure modes that burn money.

GitHub's Agent Finder discovers and invokes Claude, Codex, MCP servers, and skills automatically. Here is how the new ARD specification changes AI coding tool integration.

Stop the approval-fatigue prompts without going full YOLO mode. A hands-on guide to Claude Code's permission system - settings.json scopes, allow/deny/ask rules, tool specifiers, and the headless flags that actually matter.

A company accidentally spent $500M on Claude in one month. Uber torched its whole 2026 AI budget by April. The fix is not less AI - it is guardrails. Here is the playbook: caps, alerts, gateway spend limits, model routing, prompt caching, and approval workflows.

Databricks open-sourced Omnigent, a meta-harness that sits above individual agent CLIs so your sessions, policies, and skills are not locked inside any single tool. Here is what it does, how to install it, and where it fits if you already run Claude Code and Codex.

Z.ai shipped GLM-5.2 in mid-June with a usable 1M-token context window, two thinking-effort levels, and MIT open weights now released. Here is the setup guide for Claude Code, pricing breakdown, and what to test before the benchmarks arrive.

GitHub's latest agent workspace trend points at a boring but important primitive: agents need explicit filesystem contracts before they get more tools.

Uber burned through its entire 2026 AI tools budget by April. Microsoft is canceling Claude Code licenses company-wide. What enterprise teams can learn from the first major AI coding tool budget crises.

Claude agents vs skills, untangled: agents are workers with their own context window, skills are instructions loaded on demand. Here is the decision table.

Auto mode replaces permission prompts with a background safety classifier - here is how the Shift+Tab cycle, hard_deny rules, and glob deny patterns actually fit together.

Claude Code dynamic workflows turn orchestration into a JavaScript script that runs up to 1,000 agents per run - here is how scripts, schemas, budgets, and resume actually work.

Claude Code fast mode pricing explained: $10/$50 per MTok on Opus 4.8, the first-enable context charge, separate rate limit pools, and when 2.5x speed pays off.

Claude Code Routines and Managed Agents scheduled deployments both run Claude on a schedule - here is how the triggers, pricing, and limits differ, and which one fits your recurring agent work.

Claude Code subagents vs agent teams vs workflows: who holds the plan, the hard limits (16 concurrent, 1,000 agents per run), and which primitive fits your task.

Fable 5 effort levels explained: what low, medium, high, xhigh, and max actually change, which models support each level, and how effort drives your token bill.

An ops guide to managing a fleet of Claude agents: spawning patterns, worktree isolation, build gates, orphaned-agent failure modes, and OpenTelemetry monitoring.

Ultracode is two documented things: a prompt keyword that turns one task into a dynamic workflow, and an /effort setting that pairs xhigh reasoning with automatic orchestration. Here is exactly what the docs say.

Claude Code parallel agents cost real money because every session draws from one quota - here is the June 2026 budgeting math, verified against live pricing.

Every major AI coding tool just went through a pricing shift. Here are the exact numbers for Cursor, GitHub Copilot, Claude Code, Devin, and the Anthropic API - verified from live pricing pages on July 1, 2026. Fable 5 is back online today after export controls were lifted.

Fable 5 landed on June 9, GitHub Copilot rewired its billing on June 1, and the tool-stack decisions you made in Q1 may need a rethink. Here is where every major coding tool stands right now.

A practical comparison of the two most capable terminal-native AI coding agents in 2026 - covering pricing, model flexibility, multi-agent workflows, and which one fits your team.

Fable 5 drains the 5-hour rolling window dramatically faster than Opus or Sonnet. Here is what the plan multipliers actually mean in practice, what changes on June 22, and how to make your allocation last.

Anthropic shipped Fable 5 and a June 22 subscription cliff. OpenAI shipped GPT-5.5 inside Codex plus automations, browser use, and computer control. Here is the honest June 2026 update on which tool fits which developer.

Running multiple Claude Code agents on the same repo causes branch collisions and stash chaos - git worktrees fix this by giving each agent its own isolated directory while sharing one Git history.

Moonshot AI's Kimi CLI offers unlimited coding sessions at zero marginal cost. Claude Code offers polish, deep Anthropic integration, and a subscription most serious devs already hold. Here is how to decide.

Windsurf is now Devin Desktop, owned by Cognition after a turbulent 2025 acquisition saga. If the ownership shuffle has you reconsidering your tooling, here is a step-by-step guide to moving your workflow to Claude Code.

A Hacker News thread on config files that run code points at the next AI coding risk: agent hooks, skills, and editor rules need review like executable dependencies.

The rsync Claude debate shows why teams need reproducible defect forensics before AI attribution becomes a public blame machine.

Anthropic's open-source vulnerability harness shows where AI security work is going: reproducible exploit loops, separate verification agents, and patch receipts.

Anthropic's Claude containment writeup points to the next security layer for coding agents: deterministic capability ledgers, not another approval prompt.

The AI coding market is noisy. The changes that matter are easier to spot when you separate model capability, editor loops, terminal agents, background agents, agent frameworks, UI layers, context, security, and cost.

If I were rebuilding my AI coding workflow on May 30, 2026, I would not pick one magic tool. I would pick a layered stack: terminal agent, editor, background agent, Mastra, CopilotKit, MCP, context, security, and cost controls.

GitHub trending is full of anti-slop, taste, and compound-engineering skills. The real signal is not that agents need more prompts. It is that teams are trying to make subjective review criteria executable.

Claude Opus 4.8 looks like a benchmark bump, but the developer story is better honesty, dynamic workflows, and effort controls that make long-running agent work easier to review.

CodeGraph shows why coding agents need a local, queryable repo map. The win is not magic token savings. It is faster orientation, fewer wrong files, and better review receipts.

A front-page Hacker News essay about being tired of AI answers points at a real developer problem: chat is too easy to launder into fake work. The fix is verifiable workflows, not more conversational polish.

HKUDS/CLI-Anything hit 40,000 stars by solving a stubborn gap: most desktop software has no interface AI agents can reliably drive. Its 7-phase pipeline auto-generates a tested CLI harness from source code.

HumanLayer's 12-Factor Agents guide turns agent reliability into an engineering checklist: own prompts, context, tools, control flow, state, human approval, and observability before a demo becomes production.

Anthropic just shipped an official curated plugin directory for Claude Code. It earned 2,500+ stars in a single day and changes how you extend your AI coding workflow.

GitHub trending is full of agent skill registries. The winning pattern is not more prompts. It is dependency governance for the instructions your coding agents inherit.

Coding agents make code faster than teams can review it. The next advantage is not bigger prompts. It is review systems that force reproduction, small diffs, tests, and receipts.

AgentMemory gives Claude Code, Codex, Cursor, and other agents persistent local memory. The real adoption question is not recall accuracy. It is whether your team can inspect, prune, and govern what gets remembered.

Anthropic's June 15 Agent SDK credit split is not just a pricing tweak. It is a signal that autonomous coding workflows need separate budgets, lanes, and receipts.

Claude Code's newer plugin URL and hard-deny controls are small release-note items with a big implication: agent extensions now need supply-chain discipline.

Matt Pocock's skills repo is a useful signal for AI coding teams. The next step is treating skills like governed production controls, not a folder of viral prompts.

Persistent memory for coding agents is trending because every session still starts too cold. The hard part is not saving facts. It is proving recall, freshness, deletion, and rollback under real development pressure.

Matt Pocock's Claude Code skills repo shows the useful direction for agent workflows: small, composable skills that encode engineering discipline instead of hiding it.

Graphify is trending because coding agents keep hitting the same wall: they can edit files, but they still need a durable map of how the codebase, docs, schemas, and decisions connect.

Ruflo turns Claude Code and Codex into a larger agent harness with plugins, memory, swarms, MCP tools, and federation. The useful question is not the star count. It is how much harness you actually need.

Terminal agents like Claude Code, Codex CLI, OpenCode, Copilot CLI, and DeepSeek-TUI are converging on the same runtime layer: permissions, sandboxing, rollback, diagnostics, subagents, receipts, and cost controls.

The latest Claude Code cache-burn debate is not just a quota complaint. It is a reminder that coding agents need cache-hit telemetry, spend ceilings, and repro-grade usage logs.

31 deployed apps. 7 down. Favicons missing on 20 of 24 reachable hosts. Sentry on zero. Here is how a single audit turned into 58 PRs in one afternoon - and what shipped, what didn't, and what the pattern was.

Notes from a single session running 200+ Claude Code subagents in parallel across 35 repos. What worked, what broke, and the patterns I codified into a skill so the recipe replays.

How we ported 38 apps off Replit and onto Coolify in a single day, using parallel Claude Code subagents, gh, and neonctl. The honest stats: stubs, monorepos, false-empties, and ~120 PRs.

Claude Code 2.1.128 is full of small fixes around MCP, worktrees, OTEL, plugins, and permissions. That is exactly why it matters for teams running agents every day.

Boris Cherny's loop-heavy Claude Code workflow points at the next Codex content lane: recurring agents that babysit PRs, CI, deploys, and feedback streams.

The trending Free Claude Code repo is not just about avoiding API bills. It points at a bigger developer-tool pattern: model gateways for AI coding agents.

Addy Osmani's agent-skills repo is trending because it turns vague AI coding advice into reusable engineering checklists. The real value is not the markdown. It is the exit criteria.

Parallel agents can move faster than one agent, but only when tasks have clean ownership, review receipts, and a merge path that does not turn speed into cleanup work.

The andrej-karpathy-skills repo exploded because every coding agent needs behavioral rails. The useful move is not copying it blindly, but turning the rules into repo-specific operating constraints.

Efficient agents do not stuff every tool result into the model context. They keep intermediate state in code, files, and execution environments, then return compact summaries and receipts.

Manual approval prompts stop protecting users when coding agents ask too often. The better pattern is risk-aware autonomy: safe defaults, narrow deny rules, and approvals only for meaningful changes.

Claude Code is turning into an orchestration layer for agent teams. Here is how subagents, MCP, hooks, and long context fit together in 2026.

A long-running coding agent is only useful if the environment around it can queue tasks, capture logs, checkpoint state, verify behavior, limit cost, and recover from failure.

Skills turn a general coding agent into a trained teammate by packaging runbooks, scripts, examples, and domain-specific judgment into reusable instructions.

GitHub trending is full of agent skill frameworks. The real shift is not bigger prompts or more agents. It is turning team process into inspectable, reusable operating instructions.

I told an agent to improve the site every 10 minutes and went to sleep. Here is what 12 new repos, 60 PRs, and three goofs taught me about overnight orchestration.

The MCP ecosystem crossed 22,000 servers in early 2026. Most are noise. Here are the open-source servers that have earned a permanent slot in our config, with copy-paste setup for Claude Code, Cursor, and Codex.

Claude Code does not have to call Anthropic's API. Here are five working patterns for running it through your own gateway, on your own models, in your own VPC, with full audit logs and cost control.

Agent runs are opaque. TraceTrail turns a Claude Code JSONL into a public share link with a stepped timeline of messages, tool calls, and tokens.

A curated list of the Claude Code skills worth installing in 2026, with real install paths, what each one does, and how to build your own when nothing in the directory fits.

Hospitals still ship HL7 v2 pipes between systems in 2026. Here is how to wire Claude Code as a careful, HIPAA-aware migration agent that takes them to FHIR.

Claude Code hooks are powerful, but discovery and install still feel like manual JSON surgery. The Hookyard prototype shows what a hook package manager should become.

A curated directory of 312 Claude Code skills, plus Pro tools for authors who want analytics, version pinning, and a real submission flow.

Opus 4.7 vs GPT-5.5, the new Codex CLI vs the Claude skills ecosystem. An opinionated April 2026 verdict on which terminal agent to reach for, by job.

A repo-root DESIGN.md gives Claude Code, Codex, and other agents the design rules they need to honor so generated UI does not drift into generic territory.

Zilliz's Claude Context MCP gives coding agents semantic code search, but the real question is whether retrieval makes agent work more reviewable, cheaper, and easier to verify.

The second half of our agent tooling release: distribution, validation, and ergonomics layered on top of the first six. Six small CLIs, one through-line.

Two quality-of-life tools we built this week for Claude Code daily drivers: a SKILL.md linter and a VS Code status bar that shows live LLM spend.

Ten private tools shipped overnight - observability, skills, hooks, prompts, and evals - aimed at the agent infrastructure gap small teams keep falling into.

From Claude Opus 4.7 and GPT-5.5 to Andrej-karpathy-skills and EvoMap - the AI dev tools actually shipping the last 30 days, with commands, links, and pricing.

Four Claude-Design-adjacent repos entered the trending week with a combined 8,300+ stars. Huashu-design, open-codesign, awesome-claude-design, cc-design. Here is what is actually happening, and why the pattern matters.

Codeburn is a terminal dashboard for tracking token spend across Claude Code and Cursor. Here is what it shows, why people are reaching for it, and how it ties into the over-editing problem.
Martin Fowler reframes AI-era debt into three layers - technical, cognitive, and intent. The third one is the one most teams are silently accumulating. Here is what it is and how to diagnose it.

A new study from nrehiew quantifies a problem every Claude Code, Cursor, and Codex user has felt: models making huge diffs for tiny fixes. Here is why it happens, why tests do not catch it, and what to do about it.

From single-agent baselines to multi-level hierarchies, these are the seven patterns for wiring AI agents together in production. Each with a decision rule, an implementation sketch, and the tradeoffs that actually matter.

Zed shipped a Threads Sidebar that runs multiple agents in one window, isolated per-worktree, with per-thread agent selection. This is the first major editor to treat parallel agent orchestration as a first-class editor feature, not a plugin.

The viral Karpathy-style CLAUDE.md repo is not just a prompt trick. It shows why agent instructions, skills, plugins, and repo rules need ownership, review, and receipts.

Most MCP servers are noise. After shipping 24 apps with Claude Code, these are the five I reach for every time.

From Claude Code to Gladia, the ten CLIs every AI-native developer should know. Install commands, trade-offs, and when to reach for each.

One dev, one CLI, 24 subdomains, and a lot of parallel agents. The playbook for shipping an AI app portfolio.

Four agents, same tasks. Honest trade-offs from a developer shipping production apps with all of them.

CLAUDE.md is the highest-leverage file in any Claude Code project. Here's what goes in one, what doesn't, and the patterns that actually ship.

Skills are how you stop copy-pasting the same workflow into Claude Code every session. What they are, how to write one, and where to find hundreds ready to use. Fact-checked against Anthropic's docs.

Autocomplete wrote the line. Agents write the pull request. The shift from Copilot to Claude Code, Cursor Agent, and Devin - explained with links to the docs that prove every claim.

MCP is the USB-C of AI agents. What the Model Context Protocol is, why Anthropic built it, and how to install your first server in Claude Code or Cursor. Fact-checked against the official MCP spec.

A Q2 2026 pricing and packaging update for AI coding tools, based on official plan docs and release notes. Includes practical cost traps and selection frameworks for teams.

Updated 2026 comparison of Aider and Claude Code using official docs and current workflow patterns: architecture, control surfaces, cost behavior, and where each fits best.

A practical operational guide to Claude Code usage limits in 2026: plan behavior, API key pitfalls, routing choices, and team controls using hooks and subagents.

A deep comparison of Claude Code and OpenAI Codex app based on official docs and product updates: execution model, security controls, pricing, workflows, and when each wins.

Hacker News keeps arguing about Claude Code, Codex, skills, MCP, and orchestration. Under the noise, the same four truths keep surfacing: workflows matter more than demos, verification is the bottleneck, skills beat prompts, and orchestration matters more than raw autonomy.

The coding-agent workflow is maturing past giant hand-written prompts. The winning pattern in 2026 is a control stack: project rules, reusable skills, bounded sub-agents, and deterministic tools around the model.

A deep analysis of what AI coding tools actually cost when you factor in usage patterns, hidden limits, and real-world workflows. Pricing tables, decision matrices, and recommendations for every developer profile.

AI-native development is not about using AI tools. It is about restructuring how you plan, build, review, and ship code around agent capabilities. The five-layer stack that defines how the most productive developers work in 2026.

How to use Claude Code's Task tool, custom sub-agents, and worktrees to run parallel development workflows. Real prompt examples, agent configurations, and workflow patterns from daily use.

How to use AI agents to plan, scaffold, build, test, and deploy a SaaS product. Parallel development patterns, real workflow examples, and the operational details that determine whether your AI-assisted build succeeds or fails.

Context engineering is the practice of designing the persistent information that surrounds every AI interaction. CLAUDE.md files, system prompts, skill libraries, and memory systems. It is the single highest-leverage skill for developers working with AI agents in 2026.

An opinionated guide to the MCP server ecosystem in 2026. Curated picks by category, real configuration examples, installation commands, and honest assessments of what works and what does not.

How to go from idea to deployed SaaS product using Claude Code as your primary development tool. Project setup, feature building, deployment, and iteration.

How a single developer shipped 100+ features in one day using Claude Code, parallel agents, and the never-ending todo system.

AI agents fail in ways traditional debugging cannot catch. Here are the tools and patterns for finding and fixing broken agent loops, tool failures, and context issues.

MCP servers and function calling both let AI tools interact with external systems. They solve different problems. Here is when to reach for each.

A practical migration guide for developers switching from GitHub Copilot to Claude Code. What changes, what stays the same, and how to get productive fast.

12 AI coding tools across 4 architecture types, compared on pricing, strengths, weaknesses, and best use cases. The definitive comparison matrix for 2026.

Complete pricing breakdown for every major AI coding tool. Claude Code, Cursor, Copilot, Windsurf, Codex, Augment, and more. Free tiers, pro plans, hidden costs, and what you actually get for your money.

A free directory of 303 packaged agent workflows covers 12 careers - from contract review for lawyers to candidate scoring for recruiters.

Claude Code Channels let Telegram, Discord, iMessage, fakechat, and custom webhooks push events into a running Claude Code session. Here is when to use them, how the security model works, and where they fit beside Remote Control.

Hooks give you deterministic control over Claude Code. Auto-format on save, block dangerous commands, run tests before commits, fire desktop notifications. Here's how to set them up.

A practical guide to using Claude Code in Next.js projects. CLAUDE.md config for App Router, common workflows, sub-agents, MCP servers, and TypeScript tips that actually save time.

Terminal agent, IDE agent, local-plus-cloud agent. Three architectures compared - how to decide which fits your workflow, or why you should use all three.

Anthropic's computer use feature lets Claude see your screen, move the cursor, click, and type. Here is how it works, when to use it, and how to set it up.

A step-by-step guide to building Model Context Protocol servers in TypeScript. Project setup, tool registration, resources, testing with Claude Code, and production patterns.
A searchable directory of 184+ MCP servers organized by category. Find the right server for databases, browsers, APIs, DevOps, and more.
How to spec agent tasks that run overnight and wake up to verified, reviewable code. The spec format, pipeline, and review workflow.

The exact tools, patterns, and processes I use to ship code 10x faster with AI. From morning briefing to production deploy.

Aider is open source and works with any model. Claude Code is Anthropic's commercial agent. Here is how they compare for TypeScript.

A practical ranked list of MCP servers worth installing first for Claude Code, Cursor, Copilot, Codex, and OpenCode: GitHub, Filesystem, Context7, Playwright, Postgres, Sentry, Supabase, Notion, Slack, and more.

The definitive collection of Claude Code tips - sub-agents, hooks, worktrees, MCP, custom agents, keyboard shortcuts, and dozens of hidden features most developers never discover.

Claude Code is agent-first. Cursor is editor-first with CLI agents. Both write TypeScript. Here is how to pick the right one.

A detailed comparison of Cursor and Claude Code from someone who uses both daily. When to use each, how they differ, and the ideal setup.

A practical guide to building AI agents with TypeScript using the Vercel AI SDK. Tool use, multi-step reasoning, and real patterns you can ship today.

MCP servers connect AI agents to databases, APIs, and tools through a standard protocol. Here is how to configure and use them with Claude Code and Cursor.

Prompt engineering for coding is less about clever wording and more about task specs, repo context, constraints, examples, verification, and reviewable receipts.

Vibe coding works when you pair natural-language building with repo context, tests, diff review, security checks, and rollback. Here is the practical workflow for Claude Code, Cursor, Codex, v0, Lovable, and Bolt.

Claude Code is Anthropic's AI coding agent for terminal, IDE, desktop, and browser workflows. Learn what it does, how it works, pricing, setup, MCP, skills, hooks, and subagents.

Claude Code now has a native Loop feature for scheduling recurring prompts - from one-minute intervals to three-day windows. Fix builds on repeat, summarize Slack channels, email yourself Hacker News digests. All from the CLI.

Anthropic dropped a batch of updates across Claude Code and Cowork - remote control from your phone, scheduled tasks, plugin repos, auto memory, and stats showing 4% of GitHub public commits now come from Claude Code.

Anthropic brought git worktrees to Claude Code. Spawn multiple agents working on the same repo simultaneously - no merge conflicts, no context pollution, and your main branch stays clean.

Claude Code's popularity is not an accident. It won because terminal agents fit how software already works: files, shell commands, git, logs, project memory, and reviewable text.

Anthropic built Cowork in 1.5 weeks - a Claude Code wrapper that brings agentic AI to non-developers. Presentations, documents, project plans. Same power, no terminal required.

CloudFlare, Anthropic, and Cursor independently discovered the same pattern: don't load all tools upfront. Let agents discover what they need. The results are dramatic.

Claude Code skills can now reflect on sessions, extract corrections, and update themselves with confidence levels. Your agent gets smarter every time you use it.

The best Claude Code sessions start with questions, not code. Spec-driven development forces requirements discovery upfront - interview first, spec second, code last.

Claude Code can now control Chrome using your existing authenticated sessions. No API keys needed. Gmail, Sheets, Figma - your agent works across tabs like you do.

Skills turn Claude Code sessions into persistent memory. Successes and failures get captured, progressively disclosed, and shared across teams. Your agent remembers.

Claude Opus 4.5 ran autonomously for 4 hours 49 minutes using stop hooks and the Ralph Loop pattern. Walk away, come back to completed work. Here's how it works.

Zed is not another Electron-based editor. It's built from the ground up in Rust, which means real performance without the memory bloat that plagues other IDEs.

GitKraken Desktop bridges this gap. It is a visual Git client that shows you exactly what is happening in your repository, combined with AI that automates tedious tasks so you can stay in flow.

Anthropic's Claude Sonnet 4.5 isn't just another model increment. The company claims they've observed it maintaining focus for more than 30 hours on complex multi-step tasks.

Claude Code subagents let you split coding work across specialized assistants with their own context, tools, and instructions. The trick is using them for bounded work, not theatrical agent swarms.

AI-generated interfaces tend to look the same - gradient-heavy, emoji-laden, and generic. The style guide method gives you a reusable design system that keeps every page consistent and on-brand, whet...

After 30 days of daily use, Claude Code has become my primary coding tool. It is not trying to be an IDE or a fancy editor. It is a terminal-based AI agent that writes code, runs commands, tests its ...
Anthropic's agentic coding CLI. Runs in your terminal, edits files autonomously, spawns sub-agents, and maintains memory across sessions. Powered by Claude Opus 4.
AI CodingInteractive TUI dashboard that shows exactly where your Claude Code and Cursor tokens are going, in real time.
ProductivityMac app for running parallel Claude Code, Codex, and Cursor agents in isolated workspaces. Watch every agent work at once, then review and merge their changes.
AI CodingA hosted infinite canvas your headless AI agents drive over MCP. Any MCP-speaking agent - Claude Code, Codex, Cursor, or a script - creates HTML docs, images, and video on a live canvas, streamed in as it builds.
ProductivityThe primary command-line entry point for Claude Code sessions.
GuideReal-time prompt loop with history, completions, and multiline input.
GuideConfigure Claude Code for maximum productivity -- CLAUDE.md, sub-agents, MCP servers, and autonomous workflows.
Guide50+ customizable shortcuts for cancel, history, transcript, and more.
GuideFull vim keybindings (normal and insert modes) for prompt editing.
GuideA complete, citation-backed Claude Code course with setup, prompting systems, MCP, CI, security, cost controls, and capstone workflows.
GuideRun Bash commands with Ctrl+B and retrieve output by task ID.
GuideInstall Claude Code, configure your first project, and start shipping code with AI in under 5 minutes.
GuidePrefix prompts with ! to run shell commands directly, bypassing Claude.
GuideDeep comparison of the top AI agent frameworks - LangGraph, CrewAI, Mastra, CopilotKit, AutoGen, and Claude Code.
GuidePer-directory prompt history with Ctrl+R reverse search.
GuideHold-to-record voice input on macOS, Linux, and Windows.
GuideShift+Enter, Option+Enter, or backslash+Enter for multi-line prompts.
GuideContext-aware follow-up suggestions derived from git history.
GuideAsk quick side questions without derailing the main task.
GuideRead file contents with line limiting, offset, and binary support.
GuideCreate or overwrite files; requires permission for existing paths.
GuideTargeted edits to specific sections without rewriting entire files.
GuideBatch edit multiple files in a single atomic operation.
GuideModify Jupyter notebook cells directly without touching JSON.
GuideFile discovery via pattern matching across the repository.
GuideSearch file contents by pattern with regex support.
GuideJump to definitions, find references, and type-check via language servers.
GuideExecute shell commands with persistent working directory in project bounds.
GuideNative PowerShell execution on Windows and optionally Unix hosts.
GuideBackground monitoring of logs, files, and long-running processes.
GuideSessionStart hooks can persist env vars across Bash tool calls.
GuideStage, commit, branch, and open PRs without leaving the session.
GuideIsolated git worktrees for parallel Claude Code sessions.
GuideA practical walk-through of how to design, write, and ship a Claude Code skill - from choosing when to trigger, through allowed-tools, to the steps the agent will actually follow.
GuideClickable PR link in the footer with review state color coding.
GuideA concrete step-by-step guide to moving your development workflow from Cursor to Claude Code - settings, rules, keybindings, and the habits that transfer.
GuideFull GitHub CLI support for automated PR and issue workflows.
GuideFetch and parse content from URLs, including JS-rendered pages.
GuidePerform web searches and return ranked results with snippets.
GuidePersistent project instructions loaded every session; supports nested dirs.
GuidePath-specific rules that only load for matching files.
GuideDefine custom subagent types within your project's memory layer.
GuideAutomatic session-to-session memory of build commands, errors, and learnings.
GuideView and edit auto-memory and CLAUDE.md via the /memory command.
GuideInteractive timeline showing what's in context at each turn.
GuideAutomatic reuse of cached context for substantial cost reduction.
GuideBackground context summarization when the window starts filling up.
GuideApprove each action manually - the safest mode for new tasks.
GuideAuto-approve file edits and common filesystem commands.
GuideExplore and propose changes without executing them.
GuideEliminate prompts with a background classifier that judges safety.
GuideOnly pre-approved tools allowed. Fully non-interactive for CI.
GuideSkip all permission checks. Container and VM use only.
GuideGranular allow/ask/deny rules per tool with wildcard patterns.
GuideAuto-guarded directories like .git, .claude, and .vscode.
GuideFilesystem and network isolation for Bash tool calls on Linux and macOS.
GuideUse opus, sonnet, haiku, and best to switch models easily.
GuideHybrid mode: Opus for planning, Sonnet for execution.
GuideExtended context window for Opus and Sonnet on supported plans.
GuideLow, medium, high, xhigh, and max for adaptive reasoning control.
GuideInteractive UI to switch models and effort sliders mid-session.
Guide2.5x faster Opus at a higher token cost (research preview).
GuideToggle with Alt+T. Claude reasons through complex problems before responding.
GuideAdd gateway or custom models to the picker via environment variables.
GuideReusable markdown files with instructions and workflows.
Guide/simplify, /batch, /debug, /fast, and other built-in skills.
GuideTrigger with /skillname or let Claude auto-load when relevant.
GuideConfigure model, effort, tools, MCP servers, and invocation scope.
GuidePass arguments to skills with string substitution support.
GuideHide skills from Claude's auto-selection until manually triggered.
GuidePre-approve tools before a skill executes so it runs without prompts.
GuideRun a skill in an isolated context via fork mode.
GuideChanges to skill files are detected and reloaded automatically.
GuideSpawn isolated workers with independent context windows.
GuideResearcher, auditor, reviewer, and other ready-made subagent types.
GuideCreate reusable subagent definitions at project or user level.
GuideConfigure model, tools, MCP, skills, memory, and scoping.
GuideLimit which tools a subagent can access.
GuideRoute specific MCP servers only to specific subagents.
GuideAuto-memory that persists across multiple subagent invocations.
GuidePrevent bloating the main conversation with research or exploration.
GuideContinue a subagent's work across sessions.
GuideEvent-driven automation with 20+ lifecycle events.
GuideFires when a session begins; load env vars and initialize state.
GuideFires when a session terminates.
GuideFires before Claude processes user input; can validate or block.
GuideFires when a slash command expands; can block or inject context.
GuideFires before any tool executes. Allow, deny, defer, or modify the call.
GuideFires after a successful tool call. Good for feedback and follow-ups.
GuideFires on tool execution errors for logging, alerting, and retry.
GuideFires when a permission dialog appears. Auto-approve or auto-deny.
GuideFires when auto mode or a rule denies an action.
GuideFire when subagents spawn and finish.
GuideFire on task lifecycle events.
GuideFires when Claude finishes responding. Can prevent the stop.
GuideFires when watched files change on disk.
GuideFire when settings or CLAUDE.md files change during a session.
GuideFire before and after context compaction.
GuideFires when an MCP server requests input from the user.
GuideRun shell scripts on events with environment variable passing.
GuideUse Claude itself to handle hook logic instead of shell scripts.
GuideSpawn subagents to handle complex hook logic.
GuideRun hooks in the background without blocking the session.
GuideConnect external tools and data sources via the open MCP standard.
GuideLocal, project, user, and plugin-level MCP configurations.
GuideDeferred tool loading reduces context overhead for large MCP suites.
GuidePre-configured or dynamic OAuth for remote MCP servers.
GuideReference and read resources exposed by MCP servers.
GuideExecute MCP prompts as commands via the slash menu.
GuideReceive push messages from MCP servers via channels.
GuideAdmin-controlled allow and deny lists for MCP servers.
GuideCoordinate multiple Claude Code instances with a shared task list.
GuideCoordinator agent that assigns tasks and synthesizes findings.
GuideTeammates claim and complete work independently from one list.
GuideTeammates communicate directly without routing through the lead.
GuideRun each teammate in its own tmux or iTerm2 pane.
GuideRequire lead approval before teammates execute their tasks.
GuidePending tasks depend on others and unblock automatically.
GuideReuse custom subagent types as Agent Teams members.
GuideRun a prompt repeatedly on a fixed interval or self-paced.
GuideGUI-based scheduling on your local machine for recurring work.
GuideManaged scheduling on Anthropic infrastructure with API and GitHub triggers.
GuideKeep exploring

New tutorials, open-source projects, and deep dives on coding agents - delivered weekly.
Explore 659 topics
Browse All Topics