Advanced Scenarios

These scenarios are for engineers who are comfortable with Claude Code’s core workflows and want to push further. They cover system-level analysis with parallel subagents, extending Claude’s capabilities with MCP servers, and encoding team workflows into reusable skills.

Each scenario takes about 30 minutes and produces a tangible deliverable you can use in your real work.

---

Architecture Review

Time: 30 min | Technique: Explore-Plan-Code-Commit

The situation: You have inherited or are working in a codebase with multiple services, packages, or modules. Leadership has asked you to assess the architecture and propose the highest-impact improvement. You want to investigate the system quickly using parallel subagents rather than reading files one at a time.

What to do:

1. Start with a broad survey: Analyze the codebase structure. For each service or major module, report: its public API surface, direct dependencies on other services, database or storage usage, and any architectural patterns that concern you. Organize findings by service.
2. Dispatch parallel investigations into the areas of concern: Use subagents to investigate these areas in parallel: (1) [Area A] -- what business logic is in the wrong layer? (2) [Area B] -- how do these two modules communicate, and what are the failure modes? (3) [Area C] -- where are the resilience patterns (retries, timeouts, circuit breakers), and what is missing? For each area, report specific file paths and line numbers.
3. Synthesize into a decision record: Based on the investigation, generate an Architecture Decision Record recommending the highest-impact change. Include: context, decision, consequences (positive, negative, neutral), at least two alternatives considered with pros and cons, and specific file references from the codebase.
4. Stress-test the recommendation: Review the ADR you just generated. What is the strongest argument against your recommendation? Are there tradeoffs you understated? Would a team of your size realistically complete this in one quarter?

Success looks like: You have a formal ADR grounded in actual code references, with alternatives considered and tradeoffs documented. The investigation took 30 minutes instead of multiple hours because you used parallel subagents to eliminate hypotheses simultaneously.

---

Build an MCP Server

Time: 30 min | Technique: MCP Servers

The situation: During development, you constantly switch between your editor and another tool — a database client, an internal API dashboard, a log viewer, or a CI pipeline. You want to give Claude direct access to that data source so you can ask questions without context-switching.

What to do:

1. Choose a data source you use frequently (a database, an API, a log system) and have Claude scaffold the project: Set up a new MCP server project. Create a package.json with @modelcontextprotocol/sdk and the appropriate driver for [your data source]. Create a TypeScript entry point that initializes the MCP server and connects to [your data source]. Do not implement tools yet -- just get the skeleton running.
2. Add tools incrementally: Add a tool called [tool_name] that [describe what it does]. Include error handling for [common failure case]. Make sure the tool response follows the MCP content format. Repeat for 2-3 tools.
3. Test locally before registering: Run the server directly and verify it starts without errors. Test each tool by checking that it returns valid responses.
4. Register with Claude Code and verify: Show me how to register this MCP server with Claude Code using the claude mcp add command. After registration, verify by asking a question that requires using one of the tools.

Success looks like: You have a working MCP server registered with Claude Code that gives Claude direct access to a data source you use in your daily work. You can ask Claude questions about your data without leaving the editor.

---

Create a Custom Skill

Time: 30 min | Technique: Skills

The situation: Your team has a recurring task that eats time — writing code review comments, generating migration files, producing incident reports, or scaffolding new components. The task follows a consistent pattern, but everyone does it slightly differently. You want to encode the best version of this workflow into a reusable skill that anyone on the team can invoke with a slash command.

What to do:

1. Design before building: I want to create a Claude Code skill for [describe the task]. Before we write the SKILL.md, help me design it: What inputs should it accept? What output format works best? What constraints should I set to keep the output consistent and useful?
2. Create the skill file: Create a skill at .claude/skills/[skill-name]/SKILL.md. It should accept input via $ARGUMENTS, [describe the output format and categories], and end with [describe the summary format]. Use a constructive tone throughout.
3. Test against three different inputs: Invoke the skill with /[skill-name] followed by three different inputs that represent the range of cases it should handle (simple, complex, edge case). Evaluate each output for completeness, format consistency, and usefulness.
4. Iterate based on test results: Update the SKILL.md based on these findings: [list specific issues, e.g., missed a category, severity was inconsistent, output format varied between tests]. Show me what changed.

Success looks like: You have a tested, iterated skill in .claude/skills/ that your team can use. It produces consistent, useful output across different inputs. You have practiced the design-build-test-iterate cycle that separates a reliable skill from a one-off prompt.