Claude Code Workshop

Interface & Shortcuts LIVE DEMO

Custom Status Line

# Shows: user | directory | git branch+status | model | context %
 ehud   ~/Projects/tradeit-backend    main *↑2   Claude Opus   ctx:34%

# Set up via settings.json → statusLine config:
# { "statusLine": { "type": "command", "command": "sh ~/.claude/statusline-command.sh" } }
# The script reads JSON from stdin (model, cwd, context %) and formats it

/doctor — Check Your Health LIVE DEMO

• Run /doctor at any point to check your environment
• Shows context window usage — are you about to overflow?
• Checks plugin status, MCP connections, authentication
• Diagnoses common issues before they become problems

# Run the doctor
/doctor

# Context-mode specific diagnostics
/ctx-doctor

# Check context savings this session
/ctx-stats

The Permission Model

{
  "permissions": {
    "allow": [
      "Bash(ll)",
      "Bash(ls:*)",
      "WebSearch",
      "WebFetch(domain:github.com)",
      "mcp__wikijs__get_all_pages",
      "mcp__plugin_context-mode__ctx_stats",
      "mcp__plugin_context-mode__ctx_execute"
    ],
    "deny": []
  }
}

Step 1: Export ChatGPT History

Step 1: The Data

// conversations.json structure (simplified)
[
  {
    "title": "Fix Redis connection timeout",
    "mapping": {
      "message_id": {
        "message": {
          "author": { "role": "user" },
          "content": { "parts": ["How do I handle Redis timeouts in NestJS..."] }
        }
      }
    }
  },
  // ... 584 more conversations
]

Step 2: Let Claude Parse It LIVE DEMO

• Open Claude Code in the export directory
• Ask Claude to read and analyze conversations.json
• Claude extracts patterns: preferences, corrections, architecture knowledge

# The prompt I used (roughly):
"Read conversations.json. Analyze all 584 conversations.
 Extract:
 - My coding preferences and style rules
 - Things I corrected the AI on repeatedly
 - Architecture knowledge about our systems
 - My communication style preferences
 - External references and tools I mentioned

 Generate structured memory files in markdown format
 with frontmatter (name, description, type)."

What Claude Generated

~/.claude/projects/-Users-ehud/memory/
  MEMORY.md                          # Index linking everything
  user_profile.md                    # Role, background, expertise
  feedback_communication_style.md    # How I want AI to respond
  feedback_code_preferences.md       # Code style, patterns, tools
  feedback_mental_model.md           # How I approach problems
  feedback_common_corrections.md     # Anti-patterns from 584 sessions
  project_repos_and_architecture.md  # 37 repos, full system map
  reference_wikijs_mcp.md            # External tool references

What's Inside the Memory Files

feedback_common_corrections.md

---
name: Common corrections
description: Anti-patterns from 584 sessions
type: feedback
---

### Response anti-patterns
- "stop summarizing what you just did"
  → No trailing summaries
- "all of these links are invalid"
  → Never hallucinate URLs
- "no KEYS command, production env"
  → Be production-aware
- "only show diffs, not full file"
  → Only show changes
- "stop sending general all-options"
  → Targeted answers only

Four Memory Types

• user — role, goals, expertise level
• feedback — corrections & confirmed approaches
• project — repos, architecture, decisions
• reference — pointers to external tools

MEMORY.md Index

# Memory Index

## User
- [user_profile.md] — CTO, team, stack

## Feedback
- [feedback_communication_style.md]
- [feedback_code_preferences.md]
- [feedback_mental_model.md]
- [feedback_common_corrections.md]

## Project
- [project_repos_and_architecture.md]

## Reference
- [reference_wikijs_mcp.md]

Step 3: Compact & Deduplicate

• Raw extraction creates duplications across files
• Use the claude-md-management plugin to audit and fix
• /revise-claude-md — scans all CLAUDE.md and memory files
• Finds overlaps, merges duplicates, compacts for conciseness

# Audit and improve CLAUDE.md files
/revise-claude-md

# What it does:
# 1. Scans ALL CLAUDE.md files (global, project, memory)
# 2. Finds duplicate/overlapping information
# 3. Merges redundant entries
# 4. Reports quality score before/after
# 5. Generates diff for review

The Context Window

Understanding the #1 thing that determines Claude Code quality

The Context Explosion Problem

• Claude has a 1M token context window — sounds huge, but...
• Every file read, every command output, every search result goes in
• A single git log can dump 50KB of raw text
• Reading 10 files = hundreds of KB of context consumed
• 30 minutes of real work = 40-60% context gone

The Impact

Context Mode Plugin LIVE DEMO

How It Works

• Hooks intercept 9 tool types (Bash, Read, Grep, WebFetch, Agent...)
• Raw output is processed in a sandbox (not in context)
• Only a concise summary enters the context window
• Full data is indexed in SQLite + FTS5 for later search

Context Mode — Key Tools

# Process commands without polluting context
ctx_batch_execute(commands, queries)

# Search over previously indexed data
ctx_search(queries: ["error logs", "config values"])

# Run code in sandbox, only summary enters context
ctx_execute(language: "shell", code: "npm test")
ctx_execute_file(path: "analyze.ts", language: "typescript")

# Fetch URLs without context pollution
ctx_fetch_and_index(url: "https://docs.nestjs.com/guards")

Keeping Context Concise & Specific

The CLAUDE.md System

Example Project CLAUDE.md

# Example: project-level CLAUDE.md (committed to tradeit-backend)

## Code style
- TypeScript strict, no semicolons, camelCase
- NestJS module/service/controller pattern
- TypeORM QueryBuilder for complex queries

## Testing
- Run tests: `npm test`
- Run specific: `npm test -- --grep "TradeService"`

## Hard rules
- MySQL 8 only — no 5.7 patterns
- No KEYS in Redis — always SCAN
- No curl in Docker containers

## Directory structure
- src/modules/ — feature modules (pricing, trade, inventory)
- src/common/ — shared utilities, guards, interceptors

Per-Project Claude Settings

• Each repo can have its own .claude/settings.json
• Committed to git — shared across the team
• Project-specific permissions, allowed tools, MCP servers

// .claude/settings.json (in repo root, committed)
{
  "permissions": {
    "allow": [
      "Bash(npm test:*)",
      "Bash(npm run lint)",
      "Bash(npx prisma:*)"
    ]
  }
}

// .mcp.json (MCP servers for this project)
{
  "mcpServers": {
    "wikijs": {
      "command": "npx",
      "args": ["@cahaseler/wikijs-mcp"],
      "env": { "WIKI_URL": "https://wiki.tradeit.gg" }
    }
  }
}

Plugin System

# Install a plugin
/plugin install superpowers

# List installed plugins
/plugin list

# Disable a plugin
/plugin disable code-simplifier

Our 15 Plugins by Category

Superpowers — Workflow Engine LIVE DEMO

Enforces development discipline — skills activate contextually

The Superpowers Workflow

• Each step is gated — can't skip design and jump to code
• Plan files written to ~/.claude/plans/
• Subagents: fresh agent per task, own context window
• Verification: must run tests and show evidence before claiming "done"

Plan Mode (Shift+Tab)

# Plan mode = read-only exploration
# Claude can: read files, search code, explore codebase, ask questions
# Claude cannot: edit files, run commands, make any changes
# Perfect for: understanding code before committing to an approach

Context7 & LSP Plugins LIVE DEMO

# Claude internally calls:
resolve-library-id("nestjs")
query-docs("NestJS guards")

# Claude sees errors as it writes:
TS2345: Argument of type 'string'
  is not assignable to parameter
  of type 'number'

Commit Commands & Other Plugins

Git Workflow

# Analyze changes → conventional commit
/commit

# Commit + push + create PR (full workflow)
/commit-push-pr

# Delete local branches already merged on remote
/clean_gone

Other Useful Plugins

• code-simplifier — /simplify refactors recently changed code
• security-guidance — security review before deployment
• claude-md-management — /revise-claude-md audits and compacts config
• explanatory-output-style — adds educational insights to responses
• skill-creator — build custom skills and test them

MCP — External Integrations LIVE DEMO

Model Context Protocol — APIs that Claude can use directly from your prompt

One Prompt, Multiple Systems

"Read the Figma design at [URL] and generate a Vue component"
"Search Slack #engineering for the Redis migration discussion"
"Create a Linear ticket for this bug with the stack trace attached"
"Check our wiki for the deploy runbook and update step 3"

Skills

• Markdown files with triggers & instructions
• Teach Claude how to do workflows
• Activate automatically or via slash
• Stored in ~/.claude/skills/

---
name: my-workflow
description: Does X when Y
---

## When to activate
- User mentions "deploy"

## Instructions
1. Check branch status
2. Run tests
3. Create PR

Hooks

• Shell commands at lifecycle events
• SessionStart — inject context
• PreToolUse — intercept tools
• PostToolUse — capture output
• PreCompact — snapshot state

{
  "hooks": {
    "PreToolUse": [{
      "matcher": "Bash|Read|Grep",
      "command": "node intercept.mjs"
    }]
  }
}

Interrupt Early, Interrupt Often

Don't Let Claude Finish the Wrong Thing

• Claude is expensive — every token costs money and context space
• If you see it going the wrong direction — interrupt immediately
• Esc or Ctrl+C stops the current action, or press Enter to steer mid-task
• Letting Claude finish a wrong approach wastes:
  • Context window space (filled with useless output)
  • API tokens (you pay for wrong answers too)
  • Your time (reviewing and undoing bad changes)

The #1 Efficiency Killer

Steering Mid-Task

Steer with Enter

• While Claude is working, press Enter
• Type a correction or additional instruction
• Claude reads it without stopping
• Adjusts its approach mid-stream

# Claude is writing a service...
# You notice it's using the wrong pattern
# Press Enter and type:

"use the repository pattern instead,
 like in user.repository.ts"

# Claude adjusts without restarting

The /btw Shortcut

• Sends a side-note without interrupting the current task
• Claude incorporates it into its work
• Perfect for "oh, one more thing" moments

# Claude is mid-task and you remember:

/btw make sure to add the index
on the new column

/btw the env var is REDIS_CLUSTER_URL
not REDIS_URL

/btw we need to support Node 20 too

Efficiency Habits

Do

• Interrupt immediately when you see a wrong direction
• Use /btw for side-notes mid-task
• Use prompt queue — type next instruction while Claude works
• Plan mode first (Shift+Tab) — explore before changing
• One task per session — new session when done
• Check /doctor and /ctx-stats regularly
• Esc Esc to undo if Claude made a bad edit

Efficiency Anti-Patterns

Don't

• Let Claude finish writing code you know is wrong
• Say "try again" without changing the direction
• Mix multiple unrelated tasks in one session
• Give vague prompts and hope for the best
• Ignore the context percentage in the status line
• Read entire directories when you need one file
• Forget to /commit before starting a new task

Parallel Agents & Worktrees LIVE DEMO

1 Developer → 4 Parallel Streams

• Git worktrees — isolated copy of the repo per feature, no branch switching
• Each Claude instance has its own full context window
• Superpowers handles worktree creation automatically

Worktree Commands

# Create worktrees for parallel work
git worktree add ../feature-auth feature/auth
git worktree add ../fix-pricing fix/pricing-bug

# Launch Claude in each
cd ../feature-auth && claude
cd ../fix-pricing && claude

Multi-Repo Workspaces LIVE DEMO

When Your Feature Spans Multiple Repos

Reusable Workspaces

# Full example: creating a workspace for a multi-repo feature
mkdir -p ~/Workspaces/marketplace-aware-opensearch
cd ~/Workspaces/marketplace-aware-opensearch

# First time: launch with all repos
claude --add-dir ~/Projects/tradeit-backend \
       --add-dir ~/Projects/tradeit-inventory-parser \
       --add-dir ~/Projects/opensearch-indexing-contract

# Create workspace CLAUDE.md with feature context
# Save settings — next time just: cd here && claude

Prompt Engineering for Claude Code

"Make the code better"

"Fix the bug"

"Add tests"

"Refactor this"

"Refactor getItemPrice in
 src/modules/pricing/pricing.service.ts
 to use early-exit pattern"

"The /api/inventory endpoint returns 500
 when Redis is down. Add try/catch with
 fallback to MySQL. Follow the pattern
 in trade.service.ts"

"Add unit tests for TradeService.execute
 following the test pattern in
 trade.service.spec.ts"

Key Prompting Rules

• Reference existing files: "follow the pattern in..."
• State constraints: "no new dependencies", "must be SSR-safe"
• Use Shift+Tab (plan mode) to explore before changing
• "Try again" means different approach, not same thing with minor tweaks

Voice Mode & Image Input

Setup Checklist

# Essential (install first)
/plugin install superpowers
/plugin install context-mode
/plugin install context7
/plugin install typescript-lsp
/plugin install commit-commands

# Recommended
/plugin install linear
/plugin install code-simplifier
/plugin install security-guidance
/plugin install claude-md-management

// settings.json
{
  "model": "opus[1m]",
  "effortLevel": "high"
}

Daily Workflow & Anti-Patterns

Team Rules

• Shared CLAUDE.md per repo — committed, reviewed like code
• Review Claude's output like you'd review a human's — it makes mistakes
• Run /doctor when things feel off

Quick Reference Card

Keyboard Shortcuts

Quick Reference Card

Key Commands

Questions? Open a general Claude at ~/ and ask. Or ask me — I've made every mistake already.