Level Up Claude Code: 14 Techniques Top Engineers Use

Claude Code is powerful out of the box.

But the gap between "using Claude Code" and "getting 10x output from Claude Code" is substantial.

After months of internal usage and tracking what actually moves the needle, here are the techniques our engineers rely on daily—and that top practitioners in the space have been advocating for.

1. Force Plan-First with shift+tab or /plan

The single biggest mistake: letting Claude start coding immediately on complex features.

Press shift+tab twice or type /plan before greenfield work. This forces Claude to agree on an approach before writing any code—turning scattered attempts into coherent one-shot implementations.

The practitioner pattern: Spend a few minutes planning how to implement a feature. Once you're okay with the high-level details, let Claude implement it end-to-end in bypass mode (--dangerously-skip-permissions). The upfront planning investment pays off exponentially.

2. Supercharge Context with Tessl

Claude's native memory handles your code. But for external libraries, every session starts from scratch or from stale training data.

Tessl gives evaluated skills in the Tessl Registry, and devs can install and test any skill from GitHub.

npm i -g @tessl/cli && tessl skill search

Tiles deliver ~35% improvement in correct API usage and up to 90% on recently-released libraries where training data is sparse. You can also evals how your libraries perform with Claude Code vs Claude Code + Tessl, so you’re confident about the context level you provide.

The key insight: Claude has memory for your code (via CLAUDE.md and codebase indexing). Tiles give memory for everyone else's code—the libraries, frameworks, and APIs you depend on.

3. Mutable Memory with CLAUDE.md

CLAUDE.md is mutable project memory. The practice: update it during PRs to capture architectural decisions, edge cases, and patterns that caused rework. This prevents recurring mistakes and compounds knowledge across sessions.

What practitioners put in CLAUDE.md:

## Project Structure
- Monorepo with packages: web, api, shared
- Modular routing: API routes categorized by functionality in separate files

## Conventions
- Include comments at the top of every file explaining what it does
- This helps Claude navigate the codebase autonomously in fresh sessions

## Development Setup
- Frontend and backend run in tmux so Claude can tail logs when needed
- Use `tmux a -t dev` to attach to the development session

## Testing
- Unit tests required for every feature
- Tests run in GitHub Actions on every PR
- Using testcontainers for Postgres integration tests

The monorepo advantage: Using a monorepo is crucial for context management. Combined with modular routing (mapping frontend features to backend routes in separate files), this minimizes context pollution and helps Claude understand your architecture.

4. Connect GitHub MCP for Velocity

Wire up GitHub via MCP to let Claude review changes and merge successful PRs directly. The workflow optimizes for velocity: ship fast, revert on issues.

claude mcp add github

No more context-switching between terminal and browser for routine PR operations.

Pair with test-driven development: Add unit tests for every feature and have them run in GitHub Actions on every pull request. This gives Claude (and you) confidence to ship fast.

5. Custom Commands in .claude/commands/

Create a .claude/commands/ directory and add markdown files for frequently-used workflows. The most-used command across our team: commit-push-pr—one command that handles the entire git workflow from staged changes to opened PR.

# .claude/commands/commit-push-pr.md
Stage all changes, write conventional commit message, push to current branch, open PR with description derived from commits.

Usage:
/commit-push-pr

Other popular commands: /fix-issue [number], /new-component [name], /security-check

6. /skills for Project-Specific Automation

Skills are auto-activated behaviors based on task context. Define your own in .claude/skills/ to automate project-specific workflows—like triggering your full test suite before any PR-related command, or enforcing specific review checklists for security-sensitive directories.

The practitioner pattern: Once your code is sufficiently modularized, write SKILL files explaining how to implement each "module" in your architecture. For example:

# .claude/skills/api-routes/SKILL.md
---
name: api-routes
description: Activates when creating or modifying API endpoints
---

When creating API routes in this codebase:
1. Place route files in `api/routes/{domain}/` (e.g., `api/routes/billing/`)
2. Each route file handles one resource
3. Use the standard response wrapper from `@shared/responses`
4. Add corresponding tests in `api/routes/{domain}/__tests__/`
5. Update the route index in `api/routes/index.ts`

This teaches Claude your architecture patterns so it follows them automatically.

7. Sub-Agents for Parallel Verification

Configure sub-agents in .claude/agents/ to run post-hoc for security reviews, linting, and verification. Dispatch separate agents for Frontend, Backend, and Test coverage simultaneously—each with isolated context, preventing pollution of your main session.

# .claude/agents/security-reviewer.md
---
name: security-reviewer
description: OWASP Top 10 compliance checker
tools: Read, Grep, Glob, Bash(grep:*), Bash(rg:*)
---
Check for SQL injection, XSS, auth bypass, hardcoded secrets...

8. Hooks for Deterministic Triggers

/hooks lets you configure shell commands that fire on specific events. Useful example:

{
  "event": "waiting_for_input",
  "command": "notify-send 'Claude Code is waiting for human response!'"
}

Never miss when Claude needs your input while you're context-switched.

Other useful hooks: auto-lint after file edits, log all bash commands for audit, Slack notification on session end.

9. Agent Squad Orchestration with Worktrees

For large features, use git worktree to run 5+ Claude instances in parallel—each on its own branch, with its own context. Chain them sequentially for handoff workflows, or run fully parallel for independent modules.

git worktree add ../feat-auth feature/auth
git worktree add ../feat-api feature/api
git worktree add ../feat-ui feature/ui

# Run Claude in each (separate terminals)
cd ../feat-auth && claude
cd ../feat-api && claude
cd ../feat-ui && claude

Practitioner insight: Once you're comfortable with the basics, use 3-4 worktrees in parallel. This is where the real velocity gains come from.

Tools like Conductor help orchestrate this at scale with proper dependency management between agents.

10. YOLO Mode with -dangerously-skip-permissions

By default, Claude asks permission for every potentially impactful action. For longer autonomous tasks, this becomes a workflow killer.

claude --dangerously-skip-permissions "fix all lint errors in src/"

Safety requirements:

• Always use with version control (git reset --hard can undo anything)
• Run in Docker/VM for critical systems
• Scope tasks tightly—don't say "build a web app"

The practitioner workflow: Plan the feature first, then let Claude implement it E2E in bypass mode. The combination of upfront planning + uninterrupted execution is where the magic happens.

11. Resume Sessions with -resume

Claude Code sessions have memory and context. If you close your terminal or need to continue tomorrow, --resume picks up exactly where you left off.

claude --resume              # Resume last session
claude --resume auth-refactor  # Resume named session

12. Built-in /security-review

Claude Code ships with a built-in /security-review command that performs comprehensive security analysis—checking for SQL injection, XSS, hardcoded secrets, auth flaws, and more.

/security-review

Requirement: Must be run inside a git repository (uses git diff for analysis).

Also available as a GitHub Action for automatic PR reviews: anthropics/claude-code-security-review@main

13. Database Access with Postgres MCP

Give Claude read-only access to your database for autonomous debugging:

claude mcp add --transport http postgres-server <your-postgres-mcp-url>

This helps Claude understand your data model, debug queries, and verify data issues without you having to copy-paste query results.

The practitioner setup: Use an MCP that gives Claude read-only access. This enables autonomous debugging while preventing accidental data mutations.

14. Ralph Wiggum for Autonomous Execution

For tasks that require persistent execution until truly complete:

This runs Claude autonomously with persistent execution—useful for long-running refactors or multi-step migrations where you want completion, not partial progress. Claude retries on errors, self-corrects, and keeps working through obstacles. Get it set up using this repo.

The Compound Effect (+ CheatSheet)

Each technique helps. Combined, they compound:

The Stack:

Planning   → /plan | shift+tab ×2
Context    → CLAUDE.md + Tessl tiles + Skills
Velocity   → GitHub MCP + custom commands
Verify     → Sub-agents + /security-review
Debug      → Postgres MCP (read-only)
Scale      → Git worktrees + Conductor
Execute    → --dangerously-skip-permissions
Persist    → --resume + Ralph Wiggum

👉 You can download our full Claude code cheatsheet here. We are also working on a repo that shares all of our latest cheatsheets, and everyone can contribute! This is still a work in progress, and there is a lot more to come 🙂

The teams getting outsized results from Claude Code aren't using magic—they're stacking these techniques systematically.

These workflows are what we use internally and what leading practitioners in the space have converged on. If you're using Claude Code without them, you're leaving significant capability on the table.