Stop Prompting, Start Architecting: A Systems Approach to Claude

AI that only spits out code is like a lone bricklayer: helpful, but you won’t raise a skyscraper with bricks alone. Hands‑on coding makes up just 16–35% of a developer’s week—the rest is spent on architecture, security, performance tuning, and cross‑functional planning.

Large language models (LLMs) promise speedups—some studies show time savings on green‑field tasks—but newer field research on mature codebases finds that AI can actually slow experts by ~20%. Treating Claude as a single, all‑knowing generalist ignores these trade‑offs. To get expert‑level output, you must move from prompting to deliberate systems design.

Below is a four‑step playbook—Persona, Rules, Commands, Phases—augmented with built‑in and custom slash commands so Claude behaves like an orchestrated team of specialists rather than a chatty junior dev.

Step 1 — Define the Specialist

Use a role prompt to cast Claude as a domain expert and list its priorities:

“You are a principal security engineer for e‑commerce payment APIs.
Priority #1: prevent financial data exfiltration.
Priority #2: ensure PCI‑DSS compliance.
Review the following Go file.”

Role prompting focuses the model’s knowledge and reduces irrelevant advice. While it may not always boost factual accuracy, it does improve focus in multi‑step engineering work.

Step 2 — Set the Rules of Engagement

## Rules of Engagement
1. Read Before Write – inspect the full file before suggesting changes.
2. Evidence-Based – cite OWASP A01 or performance metrics for every recommendation.
3. No New Dependencies – do not add third-party libraries without approval.

Constraints mirror the guardrails senior engineers use every day. By front‑loading them in the prompt, you avoid costly rework later.

Step 3 — Create a Command‑Style “API” with Slash Commands

Free‑form chat is brittle; a command contract makes intent explicit and machine‑parsable. Claude Code supports two flavors:

Flavor	Where it Lives	Example & Hint
Built‑in	Packaged with Claude Code	`/review` (request code review), `/cost` (token stats), `/compact "focus on MVC folders"`
Custom	Markdown files in `.claude/commands/` (project) or `~/.claude/commands/` (user)	`/optimize` → `.claude/commands/optimize.md` `/frontend:component` → `.claude/commands/frontend/component.md`

Syntax

/<command-name> [arguments]

Quick Recipe – Project Command

mkdir -p .claude/commands
echo "Analyze this code for performance issues:" > .claude/commands/optimize.md
# Now run it
> /optimize @src/payment.go

Advanced Features

Arguments — use $ARGUMENTS placeholder to pass dynamic IDs (/fix-issue 123).
Namespacing — subdirectories create colon-separated names (/frontend:component).
Bash preamble — prefix lines with ! to inject live git status into the prompt context.
File refs — @src/utils/helpers.js pulls file contents directly.
MCP prompts — external servers can publish commands (/mcp__github__pr_review 456).

These affordances let you wire Claude into IDEs, CI pipelines, or documentation sites. And because the response schema can be enforced (e.g., structured JSON output), downstream tools can consume results automatically.

Example — Security Scan Command

COMMAND: /security-review
TARGET: ./src/handlers/payment.go
FOCUS: --sql-injection --xss

Step 4 — Orchestrate in Phases

Design — /design-api with architect persona; output contracts & non‑functional requirements.
Implement — /implement with backend persona; feed in the design doc.
Review — /security-review with security persona; flag focus areas.

Using explicit handoffs cut architecture‑review ping‑pong by ~40% in one internal pilot. (Your mileage may vary.)

From Bricklayer to Builder

Stop micromanaging a chat window. Architect the interaction: define roles, codify rules, wrap them in slash-command contracts, and run phased workflows.

Do that, and Claude becomes less a bricklayer laying GPT‑style bricks, and more the orchestrated crew chief building your entire skyscraper.