**Been an avid Claude Code user since the experimental rollout in Feb, and won the Anthropic x Forum Ventures hackathon with [zenith.chat](https://zenith.chat) alongside [@DRodriguezFX](https://x.com/DRodriguezFX) - completely using Claude Code.**
Here's my complete setup after 10 months of daily use: skills, hooks, subagents, MCPs, plugins, and what actually works.
Skills are the primary workflow surface. They act like scoped workflow bundles: reusable prompts, structure, supporting files, and codemaps when you need a particular execution pattern.
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`. Those slash entries are convenient, but the real durable unit is the underlying skill. Skills can also include codemaps - a way for Claude to quickly navigate your codebase without burning context on exploration.
ECC still ships a `commands/` layer, but it is best thought of as legacy slash-entry compatibility during migration. The durable logic should live in skills.
*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:
1.**Single CLAUDE.md** - Everything in one file (user or project level)
2.**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.
*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.
# 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.
---
## On Editors
Your editor choice significantly impacts 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](https://zed.dev) - written in Rust, so it's genuinely fast. Opens instantly, handles massive codebases without breaking a sweat, and barely touches system resources.
**Why Zed + Claude Code is a great combo:**
- **Speed** - Rust-based performance means no lag when Claude is rapidly editing files. Your editor keeps up
- **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
- **CMD+Shift+R Command Palette** - Quick access to all your custom slash commands, debuggers, build scripts in a searchable UI
- **Minimal Resource Usage** - Won't compete with Claude for RAM/CPU during heavy operations. Important when running Opus
- **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.*
**Editor-Agnostic Tips:**
1.**Split your screen** - Terminal with Claude Code on one side, editor on the other
2.**Ctrl + G** - quickly open the file Claude is currently working on in Zed
3.**Auto-save** - Enable autosave so Claude's file reads are always current
4.**Git integration** - Use editor's git features to review Claude's changes before committing
5.**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.
*The VS Code extension provides a native graphical interface for Claude Code, integrated directly into your IDE.*
---
## My Setup
### Plugins
**Installed:** (I usually only have 4-5 of these enabled at a time)
