THE COMMAND CODE

Welcome to The Command Code

You didn't buy a book. You bought an operating manual.

The difference matters. A book teaches you concepts. An operating manual shows you exactly how a machine works — what to put in, what comes out, and what happens when you turn it on.

This course is the latter. Every chapter is built around things that were actually built, prompts that were actually used, and results that actually happened. Not theory. Not hypothetical case studies. Real systems running in production right now.

Here's what this course actually gives you:

• ▶ The mental modelStop prompting like you're Googling. Start commanding like you're running a team.
• ▶ The full stackClaude Code, VS Code, GitHub, Perplexity — how they connect and why each one matters.
• ▶ Real case studiesFour complete builds, from concept to live product. Actual prompts included.
• ▶ Copyable promptsWebsite prompts, game prompts, content prompts, system prompts — every one ready to use.
• ▶ Operating modesCRUISE, BUILD, SUPERNOVA — when to use each and what changes when you do.
• ▶ The agent systemWhat agents are, who's on the roster, and how they activate based on what you describe.

There's a tier above this course — the Full System Setup ($500) — where every agent, prompt, rule, and workflow gets installed on your machine in a 2-3 hour session. This course teaches you how it works so that when you get there, you already understand what you have.

The Mental Model

The reason most people get mediocre results from AI isn't the AI. It's how they're talking to it.

They open Claude or ChatGPT and type like they're asking a question on Google. "How do I build a website?" "What's the best way to market a product?" "Can you help me write an email?"

That approach gets you generic answers. And that's exactly what it deserves.

The mental model shift is simple but it changes everything: AI is a workforce, not a search engine.

You are the commander. They are specialists. Your job is to describe what needs to be built, what constraints exist, and what done looks like. Their job is to execute.

When you give vague instructions to an employee, you get vague results. When you give specific, contextual, constrained instructions — you get production-grade output.

Notice the difference. The right column has: a target, a format, constraints, and specifics. The left column has a request with no direction.

Every chapter from here builds on this. The prompts are better because they're written by someone who understands they're issuing orders, not asking questions.

The Stack That Changes Everything

The system isn't one tool. It's five tools working together. Each one has a specific job. Together they turn a thought in your head into a deployed product you can share with a QR code.

You don't need to master all five before you start. Claude Code is the core. VS Code is how you see what it's doing. The others layer in as your workflow matures.

Case Study — pepemushroom.io

This is the one that breaks people's brains when they first hear it.

The brief: a meme token needed an arcade. A place where holders could play games, bet real money, climb leaderboards, and flex against each other using their Solana wallets.

That scope, in traditional development, is a 3-6 month project. Junior developers, senior backend engineer, UI designer, Solana integrations specialist, QA team. Six figures minimum.

One session. The system did it.

Here's exactly what was built:

The Three Games

The Infrastructure

• Solana wallet connect — Phantom + Backpack, deposit/withdraw via on-chain transactions
• Live DexScreener price feed — token price displayed in real time on every page
• Referral program — unique links, 5% of all referred spend credited automatically
• Legal pages — TOS and Privacy Policy generated to match jurisdiction requirements
• Admin panel — game configuration, prize pool management, user lookup

The point isn't to flex. The point is to recalibrate what you think is possible in a single working session when you have the right system running.

Case Study — trinitycommand.io

You're looking at it right now.

This website — the one selling you this course — was built with the exact same system this course teaches. That's not a marketing hook. It's just a fact worth sitting with for a second.

Here's what trinitycommand.io actually contains:

The reason this matters: every decision to add a feature took about 30 seconds. "Should we track analytics?" becomes "add an analytics dashboard" which becomes a working dashboard. The friction between idea and implementation is near zero.

That's the actual promise of this system. Not that it writes code for you. That it makes the cost of building something so low that you stop deciding not to build things.

Case Study — Business Sites in Hours

Not every project needs to be a crypto arcade or a multi-product platform. Sometimes the job is simpler: a client needs a website.

The process is identical. The time is dramatically compressed.

The quality isn't lower. The code is clean, mobile-responsive, and readable. The design is intentional. The deployment is proper. The only thing that changed is the time.

This matters if you're building for clients: your margins go up when your labor time drops. It matters if you're building for yourself: you can afford to build things you couldn't justify before.

Case Study — Content at Scale

The bottleneck in most content operations isn't writing. It's the combination of writing + designing + exporting + scheduling — and the fact that doing all of it consistently, every day, across multiple platforms, is genuinely exhausting for one person.

This is where the system removes the friction entirely.

Here's what actually happens in those 20 minutes:

The same approach works for email sequences, ad copy, blog posts, and video scripts. The system doesn't just generate text — it generates structured, brand-consistent assets in the correct format for the platform.

This is important: the output isn't "here's some text you can use." It's "here are 10 PNG files ready to upload to Instagram." The last mile is done.

The Anatomy of a Powerful Prompt

There's a formula. Once you see it, you can't unsee it.

Every prompt that produces great output has three components:

Three Bad Prompts vs Three Good Prompts

Why specificity produces better output

AI systems are trained on vast amounts of text. When you give a vague prompt, they have to choose from millions of possible interpretations. When you give a specific prompt, you collapse that possibility space down to exactly what you want.

The mental model: imagine a 3D shape and ask someone to "draw a shape." They'll draw a circle. Ask them to "draw a 3D isometric view of a cube, slightly rotated, with shading on the left face" and they'll draw exactly that.

Specificity isn't complexity. It's precision. A well-formed prompt takes 90 seconds to write and saves you 20 minutes of back-and-forth corrections.

Website Building Prompts

These are the actual prompts. Copy them. Edit the brackets. Run them. The output will surprise you.

The Core Website Prompt

This is the prompt template that generates 90% of all sites built with the system. Fill in the brackets — everything else is already calibrated.

Build a premium single-page website for [BUSINESS NAME].

Business type: [TYPE — e.g. executive coaching, crypto project, restaurant]
Target audience: [WHO THEY SERVE]
Tone: [e.g. premium/dark, warm/approachable, bold/energetic]

Tech stack:
- Express.js static server, ESM (type: "module")
- Port: [CHOOSE A PORT — e.g. 5360]
- Single index.html, all CSS and JS inline
- Start the server immediately after creating it

Color palette:
- Background: [HEX]
- Accent: [HEX]
- Text: [HEX]

Typography:
- Heading font: [GOOGLE FONT]
- Body font: [GOOGLE FONT]

Sections (in order):
1. Hero — [HEADLINE], [SUBHEADLINE], [CTA BUTTON TEXT]
2. About — [KEY MESSAGE]
3. Services — [LIST SERVICES]
4. Testimonials — [INCLUDE THESE OR GENERATE PLACEHOLDER]
5. Contact — [FORM FIELDS NEEDED]
6. Footer — [LINKS, SOCIAL, COPYRIGHT]

Requirements:
- Mobile-first, fully responsive (test at 375px)
- Sticky nav with hamburger menu on mobile
- Smooth scroll to sections
- Fade-in animations on scroll (IntersectionObserver)
- All touch targets 48px minimum
- Safe area insets for iPhone notch
- No placeholder text — use real copy for all sections

Mobile Enhancement Additions

Add these to any site prompt when mobile is a priority:

Additional mobile requirements:
- Viewport meta: width=device-width, initial-scale=1.0, viewport-fit=cover
- Apple mobile web app meta tags
- env(safe-area-inset-*) padding on body
- Minimum font size 16px for body text, 14px absolute minimum anywhere
- Touch targets 48px minimum height and width
- No horizontal scroll at any screen width
- Test that content is visible without JavaScript (animations are enhancement only)

QR Code Generation Prompt

Create a qr.html page in the same project directory.

The page should:
- Use qrcodejs from CDN to generate a QR code
- Display the QR code at 300x300px
- Show the URL as clickable text below the QR code
- Use the same brand colors as the main site
- Be print-friendly
- URL to encode: [THE CLOUDFLARE TUNNEL URL]

After creating qr.html, open it in the browser automatically.

Cloudflare Tunnel Deployment

The site is running on localhost:[PORT].

Run the following to create a public URL:
  cloudflared tunnel --url http://localhost:[PORT]

Wait for the tunnel URL to appear (it looks like https://[random].trycloudflare.com).
Then create a qr.html page with that URL encoded into a QR code.
Open qr.html immediately after creating it.

Game Development Prompts

Games are where this system produces the most visually striking output. You describe what you want, and a fully playable game appears in the browser. PixiJS handles the rendering — WebGL under the hood, fast enough for real-time arcade gameplay.

The Core Game Prompt Structure

Build a complete [GAME TYPE] using PixiJS v7.

Delivery format:
- Single HTML file, all CSS and JS inline
- No build step, no npm, opens directly in browser
- PixiJS loaded from CDN

Core gameplay:
[DESCRIBE THE MECHANICS IN PLAIN LANGUAGE]

Visual requirements:
- Resolution: [e.g. 800x600, fills viewport]
- Color scheme: [e.g. neon on black, pixel art, clean minimal]
- [SPECIFIC VISUAL DETAILS]

Game features:
- Main menu with start button and high score display
- Pause on Escape / mobile tap outside game area
- Game over screen with score, best score, and retry button
- High score persistence via localStorage
- Score counter visible during play

Controls:
[DESCRIBE CONTROLS — e.g. WASD to move, mouse to aim, space to shoot]
Mobile: [touch controls if needed]

Audio:
[DESCRIBE SOUND EFFECTS OR SET TO "no audio required"]

The Exact Prompts That Built Spore Flight

Build a complete infinite runner game using PixiJS v7. Single HTML file, all inline.

The player controls a glowing mushroom sprite flying horizontally through a procedurally
generated obstacle course. Obstacles are vertical pairs of organic spore columns with a gap
the player must pass through. Gap size decreases as score increases.

Visual style: bioluminescent — neon greens, purples, and cyans on deep black background.
Particle trail behind the mushroom as it flies. Obstacles glow at the edges.

Mechanics:
- Click/tap to flap upward, gravity pulls down continuously
- Obstacle speed increases every 10 obstacles
- Score increments each time player passes an obstacle pair
- Collision detection: mushroom body (not particle trail)

Required:
- Main menu with best score and START button
- Game over screen: score, best, RETRY button
- High score in localStorage key 'spore-best'
- Mobile touch support (tap anywhere to flap)
- Responsive: fills the browser viewport

Adding Ranked Mode to Any Game

The key principle from chapter 8 applies here especially: describe the physics, the visuals, the menus, and the controls. The more specific you are about behavior, the less you'll need to correct afterward.

Content Creation Prompts

Content creation is where the system produces volume. Not just text — structured, platform-formatted, brand-consistent assets ready to publish.

Instagram Campaign Prompt

Create 10 Instagram posts for [BRAND NAME].

Brand brief:
- Business: [WHAT THEY DO]
- Target: [WHO THEY SERVE]
- Tone: [e.g. bold and direct, warm and educational, premium and minimal]
- Brand colors: primary [HEX], secondary [HEX], text [HEX]
- Handle: @[HANDLE]

Content distribution (2-3 posts each):
- Educational: teach something useful related to [NICHE]
- Authority: showcase results or credentials
- Service: describe what they offer and who it's for
- Engagement: ask a question, create a discussion prompt

Each post should be rendered as an HTML div at exactly 1080x1080px with:
- Brand colors applied
- Handle visible on every post
- Strong hook text as the headline (min 24px)
- Supporting copy (min 16px)
- Consistent visual hierarchy

After creating all 10 posts:
1. Build an instagram-ads.html preview page showing all posts in a responsive grid
2. Add a Save button under each post using html2canvas
3. Create an export-pngs.js Playwright script that renders each post at full 1080x1080 to a pngs/ folder
4. Run the export script immediately

Email Sequence Prompt

Write a [NUMBER]-email sequence for [BRAND].

Sequence purpose: [WELCOME / NURTURE / LAUNCH / ONBOARDING]
Product being sold or described: [PRODUCT/SERVICE]
Audience: [WHO RECEIVES THIS]
Tone: [BRAND VOICE]

Email structure:
Email 1 — [DAY]: [SUBJECT] — [GOAL]
Email 2 — [DAY]: [SUBJECT] — [GOAL]
[CONTINUE FOR EACH EMAIL]

Rules:
- Subject lines should create curiosity or urgency without being clickbait
- Each email has one clear CTA (not multiple)
- Plain conversational language — no corporate speak
- 200-350 words per email
- P.S. line on each email (add a second hook or personal note)
- Output as clean HTML suitable for Resend/Mailchimp

Ad Copy Prompt

System Building Prompts

This is where it stops being a tool and starts being infrastructure. These prompts don't build pages. They build the backend systems that run businesses.

Full Auth + API Server

Build a complete Express.js server with authentication and a protected API.

Stack:
- Node.js ESM (type: "module")
- Express 4.x
- SQLite3 for the database (better-sqlite3)
- bcrypt for password hashing
- JWT for session tokens (jsonwebtoken)
- Port: [PORT]

Features:
1. Auth endpoints:
   POST /api/auth/register — create account (username, email, password)
   POST /api/auth/login — return JWT on success
   POST /api/auth/logout — invalidate token
   GET  /api/auth/me — return current user from token

2. Database (SQLite):
   - users table: id, username, email, password_hash, created_at
   - sessions table: id, user_id, token_hash, expires_at

3. Middleware:
   - requireAuth middleware that validates JWT on protected routes
   - Rate limiting on auth endpoints (10 req/min per IP)
   - Request logging with timestamp

4. Static file serving:
   - Serve ./public as static directory
   - All unmatched routes return public/index.html (SPA support)

Start the server and confirm it's running before finishing.

Analytics Dashboard

Add an analytics system to the existing Express server.

What to track:
- Page views (path, timestamp, user_agent, referrer, ip_hash)
- Button clicks (element_id, page, timestamp)
- Form submissions (form_id, page, timestamp — no PII)
- Checkout events (product_id, step, timestamp)

Endpoints to add:
POST /api/analytics/event — log an event (body: {type, data})
GET  /api/analytics/dashboard — return summary (admin only)

Admin dashboard page (public/admin.html):
- Shows last 7 days of page views as a bar chart (use Chart.js CDN)
- Top 10 pages by view count
- Top events by count
- Funnel: page views → checkout_start → checkout_complete
- Auto-refreshes every 60 seconds
- Protected by admin password check (simple hardcoded check is fine for now)

Client-side tracking snippet (add to all public HTML pages):
- Auto-tracks page views on load
- Tracks clicks on elements with data-track attribute
- Sends via fetch to /api/analytics/event

Referral System

Add a referral program to the existing server and database.

Logic:
- Each user gets a unique referral code on signup (8 char alphanumeric)
- Share link format: https://[DOMAIN]/?ref=[CODE]
- When a new user signs up via a referral link, record the referral relationship
- When a referred user makes a purchase, credit the referrer [X]% of the purchase value

Database additions:
- referrals table: id, referrer_id, referred_id, created_at
- referral_earnings table: id, referrer_id, purchase_id, amount, created_at

Endpoints:
GET  /api/referral/code — return current user's referral code and link
GET  /api/referral/stats — return: total referrals, total earnings, pending payout
POST /api/referral/payout — request payout (marks earnings as pending)

Dashboard widget (add to existing user dashboard):
- Referral link with copy button
- Count of successful referrals
- Total earnings to date
- Pending payout amount

Operating Modes

The system has three gears. Understanding when to use each one is what separates people who get consistent results from people who feel like output quality is random.

You activate modes by saying them. "SUPERNOVA" or "full power" or "crank it up" triggers SUPERNOVA. "BUILD mode" or "let's build" triggers BUILD. The default for anything that looks like real feature work is BUILD.

Most people default to what feels like CRUISE for everything. They get CRUISE-quality output on things that deserved SUPERNOVA. The mode is the multiplier.

The Agent System

Agents are specialized AI personas — each one with a defined role, a skill set, and a specific context about how to approach work in their domain.

You don't need to know which agent does what. You describe the work, and the right agent activates. But understanding the roster helps you understand what the system is capable of.

The power of the agent system is that each specialist brings focused, deep context to their domain. A code reviewer who only reviews code has better pattern recognition on code problems than a generalist. A security reviewer who only thinks about security catches things a generalist misses.

This is why the system produces better output than a single chatbot: it's not one generalist trying to do everything. It's a team of specialists, each doing exactly one thing well.

Memory and Persistence

One of the biggest frustrations people have with AI is that it forgets. Every session starts from zero. You re-explain your project, your preferences, your constraints — over and over again.

The system solves this with a layered memory architecture.

Layer 1: CLAUDE.md — Project Brain

Every project has a CLAUDE.md file in its root directory. When Claude Code opens in a project, it reads this file first. It contains everything the AI needs to know to work on the project without being briefed each session.

# Project: [NAME]

## What this is
[1-2 sentence description of the project]

## Tech stack
- Node.js ESM, Express 4.x
- SQLite3 (better-sqlite3)
- Frontend: vanilla HTML/CSS/JS, single-file pages
- Port: [PORT]

## File structure
[BRIEF MAP OF KEY FILES]

## Rules
- All pages are single HTML files with inline CSS and JS
- No React, no Vue, no build toolchain
- Mobile-first always
- Error handling on every API endpoint
- Never hardcode secrets — use .env

## Current state
[WHAT'S BUILT, WHAT'S IN PROGRESS, WHAT'S NEXT]

## Known issues
[ANY KNOWN BUGS OR INCOMPLETE WORK]

Layer 2: Global Memory Files

The Full System includes a global memory layer — files that persist across all projects and all sessions. These contain your working style, your preferences, your active projects, your decisions, and your feedback. Every session builds on every previous session.

The memory index is at ~/.claude/projects/memory/MEMORY.md — a reference file that points to individual memory files organized by category. When you start a session, the context isn't just the current project. It includes who you are and how you work.

Layer 3: Session Logs

Every session gets logged — what was built, what decisions were made, what was deferred. Stored in Obsidian or flat files. The next session reads the log and picks up exactly where the previous one ended.

This is the compounding effect applied to your AI workflow. The system gets more useful over time because it knows more about you, your projects, and what works. The first session is the weakest session you'll ever have.

The Daily Workflow

Here's what a day actually looks like when the system is running.

What changed isn't that you're working less. It's that everything you do produces more output per hour. The ideas you had for your business that you never had time to build — you have time now.

What's Possible Next

You've seen the examples. You've read the prompts. You understand the workflow. Here's what you don't know yet — and you'll only discover it by doing it.

The first time you run a game prompt and a fully playable arcade game appears in your browser — that moment is different when it happens to you versus reading about it. The first time you describe a backend system and a working API appears — the gap between idea and reality collapses in a way that permanently changes your sense of what's possible.

The people who run this workflow for 90 days don't come back and say "it was good." They come back and say they don't understand how they operated before this. That's not hyperbole — that's the actual feedback pattern.

Your Path Forward

18 chapters. You now understand how this system actually works — not in theory, but in practice. You've seen what it built, you have the prompts that built it, and you know the workflow that makes it repeatable.

That puts you somewhere. Not at the finish line — but ahead of where you were two hours ago by a meaningful margin.

There's a gap between knowing this and having it running. That gap is either something you close yourself over 2-3 months, or something we close for you in 2-3 hours. Both are real options. Here's what each one looks like: