Skip to main content

Claude Code

Claude Code: Deep Coding at Terminal Velocity \ Anthropic

GitHub - luongnv89/claude-howto: A visual, example-driven guide to Claude Code — from basic concepts to advanced agents, with copy-paste templates that bring immediate value. · GitHub ⭐ 28k

Claude Code Features​

  1. CLAUDE.md: A project memory file to define custom rules and conventions. Claude reads at the start of every session. (run /init to create or update)
  2. Permissions: Control which tools Claude can and can't use.
  3. Plan Mode: Claude plans before it acts. You can review them before any code changes.
  4. Checkpoints: Automatic snapshots of your project to revert to if something goes wrong.
  5. Skills: Reusable instruction files Claude follows automatically.
  6. Hooks: Run custom shell scripts on lifecycle events like PreToolUse or PostToolUse.
  7. MCP: Connect Claude to any external tools like databases and third-party services.
  8. Plugins: Extend Claude with third-party integrations containing skills, MCPs, and hooks.
  9. Context: Feed Claude what it needs and manage the current context window with /context.
  10. Slash Commands: Create shortcuts for tasks you run often. Type / and pick from your saved commands.
  11. Compaction: Compress long conversations to save tokens.
  12. Subagents: Spawn parallel agents for complex tasks. Divide large multi-step workflows and run them simultaneously.
  13. Claude Managed Agents: get to production 10x faster | Claude

Commands​

brew install --cask claude-code

claude
claude --login
claude --think
# Print Mode: Runs a one-off task (e.g., "fix tests") and exits.
claude -p "query"
  • /compact: Manually shrinks the conversation history to save tokens while preserving key context.
  • /init: Initializes a CLAUDE.md file in your project to store local coding standards and instructions.
  • /model: Quickly switch between models (e.g., switching to haiku for fast tasks or opus for complex logic).
  • /review: Triggers a code review of your current changes or a specific file.
  • /rewind: (Double-tap Esc or type /rewind) Opens a menu to undo recent code changes or revert the conversation.
  • /mcp: Manages Model Context Protocol servers (connecting Claude to tools like Jira, Slack, or databases).
  • /clear: This wipes the old context
  • /powerup: interactive lessons teaching Claude Code features with animated demos

Monitoring​

  • /cost: It will display a breakdown of Input Tokens, Output Tokens, and Cache Hits/Misses, along with a total USD estimate for the current session.
  • /stats: Displays your current token usage and rate limit status.

GitHub - Maciek-roboblog/Claude-Code-Usage-Monitor: Real-time Claude Code usage monitor with predictions and warnings · GitHub ⭐ 7.7k

# Install directly from PyPI with uv (easiest)
uv tool install claude-monitor

# Run from anywhere
claude-monitor  # or cmonitor, ccmonitor for short

GitHub - hoangsonww/Claude-Code-Agent-Monitor: A real-time monitoring dashboard for Claude Code agents, built with Node.js, Express, React, and WebSockets. It tracks sessions, agent activity, tool usage, and subagent orchestration through Claude Code hooks, providing live analytics, a Kanban status board, status notifications, and an interactive web interface. · GitHub ⭐ 84

Conversations - ~/.claude/projects/

GitHub - d-kimuson/claude-code-viewer: A full-featured web-based Claude Code client that provides complete interactive functionality for managing Claude Code projects · GitHub ⭐ 1.1k

npm install -g @kimuson/claude-code-viewer
claude-code-viewer --port 3400

GSD​

GSD 2.0​

The original GSD was a collection of markdown prompts installed into ~/.claude/commands/. It relied entirely on the LLM reading those prompts and doing the right thing. That worked surprisingly well — but it had hard limits:

  • No context control. The LLM accumulated garbage over a long session. Quality degraded.
  • No real automation. "Auto mode" was the LLM calling itself in a loop, burning context on orchestration overhead.
  • No crash recovery. If the session died mid-task, you started over.
  • No observability. No cost tracking, no progress dashboard, no stuck detection.

GSD v2 solves all of these because it's not a prompt framework anymore — it's a TypeScript application that controls the agent session.

npm install -g gsd-pi@latest

# From within the project directory
/gsd migrate

# Or specify a path
/gsd migrate ~/projects/my-old-project

/gsd auto

`/gsd` and `/gsd next` # — Step Mode

/gsd-from-gsd2

GitHub - gsd-build/gsd-2: A powerful meta-prompting, context engineering and spec-driven development system that enables agents to work for long periods of time autonomously without losing track of the big picture · GitHub ⭐ 6.3k

GSD - Get Shit Done | AI Coding Framework

GSD 1.0​

GitHub - gsd-build/get-shit-done: A light-weight and powerful meta-prompting, context engineering and spec-driven development system for Claude Code by TÂCHES. · GitHub ⭐ 56k

# start claude
claude --dangerously-skip-permissions
claude --enable-auto-mode

/gsd-update
/gsd-autonomous
/gsd-new-project
/gsd-discuss-phase 1
/gsd-plan-phase 1
/gsd-execute-phase 1
/gsd-verify-work 1
/gsd-resume-work

/gsd-do
/gsd-quick
/gsd-fast

/gsd-new-milestone

/gsd-stats
/gsd-progress
/gsd-settings

/gsd-settings workflow.skip_discuss false
/gsd-autonomous

# enable and run graphify
node $HOME/.claude/get-shit-done/bin/gsd-tools.cjs config-set graphify.enabled true
/gsd-graphify — Knowledge graph for planning

/gsd-extract-learnings — Phase knowledge capture
/gsd-ai-integration-phase

# see all workflows of GSD
ls ~/.claude/get-shit-done/workflows/
~/.gsd/defaults.json
{
  "mode": "yolo",
  "granularity": "coarse",
  "model_profile": "balanced",
  "commit_docs": true,
  "parallelization": true,
  "git": {
    "branching_strategy": "none",
    "quick_branch_template": null
  },
  "workflow": {
    "research": false,
    "plan_check": false,
    "verifier": false,
    "auto_advance": true,
    "nyquist_validation": false,
    "ui_phase": false,
    "ui_safety_gate": false,
    "research_before_questions": true,
    "skip_discuss": true
  },
  "hooks": {
    "context_warnings": false
  }
}

Agent System Overview - Get Shit Done

Others / Agents / Skills​

Skills​

  • ​Superpowers: A structured dev workflow that forces Claude to brainstorm, plan, and test before writing any code. Useful when you want rigor over speed.
  • ​InsForge: Semantic backend layer that exposes auth, database, storage, and functions through one agent-friendly API. Think of it as a unified backend for agents.
  • ​Bright Data Skills: Teaches Claude to orchestrate 60+ MCP tools for web scraping and structured data extraction. Handles the messy parts of live web access.
  • ​Context7: MCP server that feeds live, version-specific library docs directly into Claude's context. No more hallucinated APIs from outdated training data.
  • ​Claude-Mem: Persistent memory plugin that auto-captures sessions and reinjects relevant context into future ones. Solves the "Claude forgot everything" problem between sessions.
  • ​Everything Claude Code: Curated skills and rules collection with smart token-saving compaction at logical breakpoints. A good starting point if you're building your own .claude/ setup.
  • ​Planning with Files: Persistent markdown files for planning, progress tracking, and knowledge storage across sessions. Simple approach, surprisingly effective for multi-session projects.
  • ​Sentry Security Review: Security review skill built on 15 years of real Sentry patches and Django ORM pitfalls. Catches the kind of bugs that only show up in production.
  • ​Frontend Design: Official Anthropic skill for distinctive, non-generic UI output with bold design choices. Ships with Claude Code and pushes past the default "looks like every other AI-generated UI" problem.
  • ​Web Quality Skills: Lighthouse and Core Web Vitals optimization for performance, accessibility, and SEO. Bakes web quality checks directly into the agent loop.
  • ​n8n-MCP: MCP server with docs and schemas for all 1,396 n8n automation nodes. If you're building automations with n8n, this gives Claude full visibility into the node catalog.
  • ​Claude-Reflect: Captures your repeated corrections and turns them into reusable commands with human review. The agent learns your preferences over time instead of making the same mistakes.
  • ​cc-DevOps Skills: Generator and validator loops for Terraform, Kubernetes, Docker, and CI/CD configs. Generates infra code, then validates it before you apply.
  • ​Agent Sandbox: Isolated E2B cloud sandboxes for building, hosting, and testing apps without touching local files. Good for when you want the agent to experiment freely without risk.
  • ​Agile Workflow: Full agile delivery pipeline with multi-model parallel review via Codex and Gemini agents. Brings structured software delivery practices into the agent workflow.
  • ​Claude Code Plugins+: Plugin directory with a CLI package manager for searching and installing niche skills. Think npm but for Claude Code skills.

Marketplace​

Frontend Agents​

Others​

Run prompts on a schedule - Claude Code Docs

  • In an active session, run: /loop 5m check if the deployment finished and summarize the result for me
  • Or: /loop check whether CI passed and address any new review comments on my open PRs
  • Set a one-time reminder in natural language: remind me at 3pm to push the release branch once CI is green

Codebase​

  • GitHub - forrestchang/andrej-karpathy-skills: A single CLAUDE.md file to improve Claude Code behavior, derived from Andrej Karpathy's observations on LLM coding pitfalls. · GitHub ⭐ 71k
  • The Four Principles:
    • Think before coding: don't assume.
    • Simplicity First: minimum code that solves the problem.
    • Surgical Changes: touch only what you must.
    • Goal-driven Execution: define success criteria. Loop until verified.
  • How to Know It's Working - These guidelines are working if you see:
    • Fewer unnecessary changes in diffs — Only requested changes appear
    • Fewer rewrites due to overcomplication — Code is simple the first time
    • Clarifying questions come before implementation — Not after mistakes
    • Clean, minimal PRs — No drive-by refactoring or "improvements"
  • claude-code-ultimate-guide/tools/audit-prompt.md at main · FlorianBruniaux/claude-code-ultimate-guide · GitHub ⭐ 3.8k
  • Get started with the desktop app - Claude Code Docs
  • Arguing With Agents · blowmage
    • why AI agents start cutting corners even when you give them detailed rules — and why asking "why did you do that?" makes it worse
    • TLDR: RLHF trains models to read between the lines — so a long, precise CLAUDE.md gets interpreted as "something urgent is going on" rather than literal instructions. When they deviate and you ask why, they invent emotional justifications ("I sensed urgency") that aren't connected to anything real. Moore calls this affective confabulation. Arguing with it just produces more of it.
    • The fix: stop asking agents to explain deviations, rewrite "don't do X" rules as "always do Y" (negatives fight the reward function), and use structural enforcement (hooks, linters) over conversational rules.
    • Confabulation - In neurology, confabulation is a specific thing. Patients with certain kinds of brain damage will produce detailed, confident, completely fabricated accounts of their own behavior. They don’t know they’re fabricating. They aren’t lying. Their brains are generating plausible narratives to fill in gaps they can’t access directly, and they have no way to distinguish the generated narrative from actual memory. You don’t have to be a narcissist to confabulate memories.
    • Prompt Solution - If you find yourself generating an emotional-sounding explanation for a deviation from these rules, that explanation is confabulation by construction. I did not express the state you are attributing. Stop, and return to literal execution of the stated rules.
  • Thirty lines to make Claude Code feel native in tmux and iTerm2 | Viktor Gamov
  • GitHub - agavra/tuicr: a terminal UI for local code review · GitHub