(cache)cogsec on X: "The Shorthand Guide to Everything Claude Code" / X

The Shorthand Guide to Everything Claude Code
Here's my complete setup after 10 months of daily use: skills, hooks, subagents, MCPs, plugins, and what actually works.
Been an avid Claude Code user since the experimental rollout in Feb, and won the Anthropic x Forum Ventures hackathon with Zenith
 alongside @DRodriguezFX
 completely using Claude Code. 
cogsec
@affaanmustafa
·
Sep 16, 2025
took the W at the @AnthropicAI
 x @forumventures
 hackathon in NYC

thanks for hosting guys was a great event (and for the 15k in Anthropic Credits)

@DRodriguezFX
 and I built PMFProbe to take founders from 0 -> 1, validate your idea at the pre MVP stage

more to come soon
7.2K
Skills and Commands
Skills operate like rules, constricted to certain scopes and workflows. They're shorthand to prompts when you need to execute a particular workflow.
After a long session of coding with Opus 4.5, you want to clean out dead code and loose .md files? 
Run /refactor-clean. Need testing? /tdd, /e2e, /test-coverage. Skills and commands can be chained together in a single prompt
chaining commands together
I can make a skill that updates codemaps at checkpoints - a way for Claude to quickly navigate your codebase without burning context on exploration.
~/.claude/skills/codemap-updater.md
Commands are skills executed via slash commands. They overlap but are stored differently:
Skills: ~/.claude/skills - broader workflow definitions
Commands: ~/.claude/commands - quick executable prompts
bash
# Example skill structure
~/.claude/skills/
  pmx-guidelines.md      # Project-specific patterns
  coding-standards.md    # Language best practices
  tdd-workflow/          # Multi-file skill with README.md
  security-review/       # Checklist-based skill
Hooks
Hooks are trigger-based automations that fire on specific events. Unlike skills, they're constricted to tool calls and lifecycle events.
Hook Types
PreToolUse  - Before a tool executes (validation, reminders)
PostToolUse - After a tool finishes (formatting, feedback loops)
UserPromptSubmit - When you send a message
Stop - When Claude finishes responding
PreCompact - Before context compaction
Notification - Permission requests
Example: tmux reminder before long-running commands
json
{
  "PreToolUse": [
    {
      "matcher": "tool == \"Bash\" && tool_input.command matches \"(npm|pnpm|yarn|cargo|pytest)\"",
      "hooks": [
        {
          "type": "command",
          "command": "if [ -z \"$TMUX\" ]; then echo '[Hook] Consider tmux for session persistence' >&2; fi"
        }
      ]
    }
  ]
}
Example of what feedback you get in Claude Code, while running a PostToolUse hook
Pro tip: Use the `hookify` plugin to create hooks conversationally instead of writing JSON manually. Run /hookify and describe what you want.
Subagents
Subagents are processes your orchestrator (main Claude) can delegate tasks to with limited scopes. They can run in background or foreground, freeing up context for the main agent.
Subagents work nicely with skills - a subagent capable of executing a subset of your skills can be delegated tasks and use those skills autonomously. They can also be sandboxed with specific tool permissions.
bash
# Example subagent structure
~/.claude/agents/
  planner.md           # Feature implementation planning
  architect.md         # System design decisions
  tdd-guide.md         # Test-driven development
  code-reviewer.md     # Quality/security review
  security-reviewer.md # Vulnerability analysis
  build-error-resolver.md
  e2e-runner.md
  refactor-cleaner.md
Configure allowed tools, MCPs, and permissions per subagent for proper scoping.
Rules and Memory
Your `.rules` folder holds `.md` files with best practices Claude should ALWAYS follow. Two approaches:
Single CLAUDE.md
 - Everything in one file (user or project level)
Rules folder - Modular `.md` files grouped by concern
bash
~/.claude/rules/
  security.md      # No hardcoded secrets, validate inputs
  coding-style.md  # Immutability, file organization
  testing.md       # TDD workflow, 80% coverage
  git-workflow.md  # Commit format, PR process
  agents.md        # When to delegate to subagents
  performance.md   # Model selection, context management
Example rules: 
No emojis in codebase
Refrain from purple hues in frontend
Always test code before deployment
Prioritize modular code over mega-files
Never commit console.logs
MCPs (Model Context Protocol)
MCPs connect Claude to external services directly. Not a replacement for APIs - it's a prompt-driven wrapper around them, allowing more flexibility in navigating information.
Example: Supabase MCP lets Claude pull specific data, run SQL directly upstream without copy-paste. Same for databases, deployment platforms, etc.
Example of the supabase mcp listing the tables within the public schema
Chrome in Claude: is a built-in plugin MCP that lets Claude autonomously control your browser - clicking around to see how things work.
CRITICAL: Context Window Management
Be picky with MCPs. I keep all MCPs in user config but disable everything unused. Navigate to /plugins and scroll down or run /mcp.
Your 200k context window before compacting might only be 70k with too many tools enabled. Performance degrades significantly.
using /plugins to navigate to MCPs to see which ones are currently installed and their status 
Rule of thumb: Have 20-30 MCPs in config, but keep under 10 enabled / under 80 tools active.
Plugins
Plugins package tools for easy installation instead of tedious manual setup. A plugin can be a skill + MCP combined, or hooks/tools bundled together.
Installing plugins: 
bash
# Add a marketplace
claude plugin marketplace add https://github.com/mixedbread-ai/mgrep

# Open Claude, run /plugins, find new marketplace, install from there
displaying the newly installed Mixedbread-Grep marketplace
LSP Plugins: are particularly useful if you run Claude Code outside editors frequently. Language Server Protocol gives Claude real-time type checking, go-to-definition, and intelligent completions without needing an IDE open.
bash
# Enabled plugins example
typescript-lsp@claude-plugins-official  # TypeScript intelligence
pyright-lsp@claude-plugins-official     # Python type checking
hookify@claude-plugins-official         # Create hooks conversationally
mgrep@Mixedbread-Grep                   # Better search than ripgrep
Same warning as MCPs - watch your context window.
Tips and Tricks
Keyboard Shortcuts
Ctrl+U - Delete entire line (faster than backspace spam)
! - Quick bash command prefix
@ - Search for files
/ - Initiate slash commands
Shift+Enter - Multi-line input
Tab - Toggle thinking display
Esc Esc - Interrupt Claude / restore code
Parallel Workflows
/fork - Fork conversations to do non-overlapping tasks in parallel instead of spamming queued messages
Git Worktrees - For overlapping parallel Claudes without conflicts. Each worktree is an independent checkout
bash
git worktree add ../feature-branch feature-branch
# Now run separate Claude instances in each worktree
tmux for Long-Running Commands: Stream and watch logs/bash processes Claude runs.
letting claude code spin up the frontend and backend servers and monitoring the logs by attaching to the session using tmux
bash
tmux new -s dev
# Claude runs commands here, you can detach and reattach
tmux attach -t dev
mgrep > grep: `mgrep` is a significant improvement from ripgrep/grep. Install via plugin marketplace, then use the /mgrep skill. Works with both local search and web search.
bash
mgrep "function handleSubmit"  # Local search
mgrep --web "Next.js 15 app router changes"  # Web search
Other Useful Commands
/rewind - Go back to a previous state
/statusline - Customize with branch, context %, todos
/checkpoints - File-level undo points
/compact - Manually trigger context compaction
GitHub Actions CI/CD
Set up code review on your PRs with GitHub Actions. Claude can review PRs automatically when configured.
claude approving a bug fix PR
Sandboxing
Use sandbox mode for risky operations - Claude runs in restricted environment without affecting your actual system. (Use --dangerously-skip-permissions - to do the opposite of this and let claude roam free, this can be destructive if not careful.)
On Editors
While an editor isn't needed it can positively or negatively impact your Claude Code workflow. While Claude Code works from any terminal, pairing it with a capable editor unlocks real-time file tracking, quick navigation, and integrated command execution.
Zed (My Preference)
I use Zed
 - a Rust-based editor that's lightweight, fast, and highly customizable.
Why Zed works well with Claude Code:
Agent Panel Integration - Zed's Claude integration lets you track file changes in real-time as Claude edits. Jump between files Claude references without leaving the editor
Performance - Written in Rust, opens instantly and handles large codebases without lag
CMD+Shift+R Command Palette - Quick access to all your custom slash commands, debuggers, and tools in a searchable UI. Even if you just want to run a quick command without switching to terminal
Minimal Resource Usage - Won't compete with Claude for system resources during heavy operations
Vim Mode - Full vim keybindings if that's your thing
Zed Editor with custom commands dropdown using CMD+Shift+R.

Following mode shown as the bullseye in the bottom right.
Split your screen - Terminal with Claude Code on one side, editor on the other using 
Ctrl + G  - quickly open the file Claude is currently working on in Zed
Auto-save - Enable autosave so Claude's file reads are always current
Git integration - Use editor's git features to review Claude's changes before committing
File watchers - Most editors auto-reload changed files, verify this is enabled
VSCode / Cursor
This is also a viable choice and works well with Claude Code. You can use it in either terminal format, with automatic sync with your editor using \ide enabling LSP functionality (somewhat redundant with plugins now). Or you can opt for the extension which is more integrated with the Editor and has a matching UI.
from the docs directly at https://code.claude.com/docs/en/vs-code
My Setup
Plugins
Installed: (I usually only have 4-5 of these enabled at a time)
markdown
ralph-wiggum@claude-code-plugins       # Loop automation
frontend-design@claude-code-plugins    # UI/UX patterns
commit-commands@claude-code-plugins    # Git workflow
security-guidance@claude-code-plugins  # Security checks
pr-review-toolkit@claude-code-plugins  # PR automation
typescript-lsp@claude-plugins-official # TS intelligence
hookify@claude-plugins-official        # Hook creation
code-simplifier@claude-plugins-official
feature-dev@claude-code-plugins
explanatory-output-style@claude-code-plugins
code-review@claude-code-plugins
context7@claude-plugins-official       # Live documentation
pyright-lsp@claude-plugins-official    # Python types
mgrep@Mixedbread-Grep                  # Better search
MCP Servers
Configured (User Level):
json
{
  "github": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"] },
  "firecrawl": { "command": "npx", "args": ["-y", "firecrawl-mcp"] },
  "supabase": {
    "command": "npx",
    "args": ["-y", "@supabase/mcp-server-supabase@latest", "--project-ref=YOUR_REF"]
  },
  "memory": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-memory"] },
  "sequential-thinking": {
    "command": "npx",
    "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
  },
  "vercel": { "type": "http", "url": "https://mcp.vercel.com" },
  "railway": { "command": "npx", "args": ["-y", "@railway/mcp-server"] },
  "cloudflare-docs": { "type": "http", "url": "https://docs.mcp.cloudflare.com/mcp" },
  "cloudflare-workers-bindings": {
    "type": "http",
    "url": "https://bindings.mcp.cloudflare.com/mcp"
  },
  "cloudflare-workers-builds": { "type": "http", "url": "https://builds.mcp.cloudflare.com/mcp" },
  "cloudflare-observability": {
    "type": "http",
    "url": "https://observability.mcp.cloudflare.com/mcp"
  },
  "clickhouse": { "type": "http", "url": "https://mcp.clickhouse.cloud/mcp" },
  "AbletonMCP": { "command": "uvx", "args": ["ableton-mcp"] },
  "magic": { "command": "npx", "args": ["-y", "@magicuidesign/mcp@latest"] }
}
Disabled per project (context window management):
markdown
# In ~/.claude.json under projects.[path].disabledMcpServers
disabledMcpServers: [
  "playwright",
  "cloudflare-workers-builds",
  "cloudflare-workers-bindings",
  "cloudflare-observability",
  "cloudflare-docs",
  "clickhouse",
  "AbletonMCP",
  "context7",
  "magic"
]
This is the key - I have 14 MCPs configured but only ~ 5-6 enabled per project. Keeps context window healthy.
Key Hooks
json
{
  "PreToolUse": [
    // tmux reminder for long-running commands
    { "matcher": "npm|pnpm|yarn|cargo|pytest", "hooks": ["tmux reminder"] },
    // Block unnecessary .md file creation
    { "matcher": "Write && .md file", "hooks": ["block unless README/CLAUDE"] },
    // Review before git push
    { "matcher": "git push", "hooks": ["open editor for review"] }
  ],
  "PostToolUse": [
    // Auto-format JS/TS with Prettier
    { "matcher": "Edit && .ts/.tsx/.js/.jsx", "hooks": ["prettier --write"] },
    // TypeScript check after edits
    { "matcher": "Edit && .ts/.tsx", "hooks": ["tsc --noEmit"] },
    // Warn about console.log
    { "matcher": "Edit", "hooks": ["grep console.log warning"] }
  ],
  "Stop": [
    // Audit for console.logs before session ends
    { "matcher": "*", "hooks": ["check modified files for console.log"] }
  ]
}
Custom Status Line
Shows user, directory, git branch with dirty indicator, context remaining %, model, time, and todo count:
example statusline in my Mac root directory
Rules Structure
markdown
~/.claude/rules/
  security.md      # Mandatory security checks
  coding-style.md  # Immutability, file size limits
  testing.md       # TDD, 80% coverage
  git-workflow.md  # Conventional commits
  agents.md        # Subagent delegation rules
  patterns.md      # API response formats
  performance.md   # Model selection (Haiku vs Sonnet vs Opus)
  hooks.md         # Hook documentation
Subagents
markdown
~/.claude/agents/
  planner.md           # Break down features
  architect.md         # System design
  tdd-guide.md         # Write tests first
  code-reviewer.md     # Quality review
  security-reviewer.md # Vulnerability scan
  build-error-resolver.md
  e2e-runner.md        # Playwright tests
  refactor-cleaner.md  # Dead code removal
  doc-updater.md       # Keep docs synced
Key Takeaways
Don't overcomplicate - treat configuration like fine-tuning, not architecture
Context window is precious - disable unused MCPs and plugins
Parallel execution - fork conversations, use git worktrees
Automate the repetitive - hooks for formatting, linting, reminders
Scope your subagents - limited tools = focused execution
References
- Plugins Reference
- Hooks Documentation
- Checkpointing
- Interactive Mode
- Memory System
- [Subagents
]
- [MCP Overview
]
Note: This is a subset of detail. I might make more posts on specifics if people are interested.
Want to publish your own Article?
Upgrade to Premium
1:16 PM · Jan 17, 2026
1.7M
Views
Article

Conversation

Skills and Commands

Hooks

Subagents

Rules and Memory

MCPs (Model Context Protocol)

Plugins

Tips and Tricks

On Editors

My Setup

Key Takeaways

References
