Everyone argues about model choice. Claude vs GPT vs Grok. But here's the move nobody talks about: model choice doesn't matter half as much as what you feed it first. A great system prompt beats a better model every single time. The leverage isn't the tool — it's the instructions you lock in before the tool even thinks.
Aidxn's answer is system prompt engineering. We encode brand voice, tone rules, and technical constraints into `.claude/CLAUDE.md` (Claude Code), `.cursor/rules` (Cursor), `.github/copilot-instructions.md` (GitHub Copilot), and agent prompts (Codex). Same canonical source. Every tool reads it first. Zero tone drift. Zero "can you make this sound like us?"
Why Model Choice Loses to System Prompts
You buy the fancy model and it still writes like a corporate training manual if you don't tell it not to. Switch to a cheaper model with a locked system prompt and suddenly it sounds like your brand. The difference between "unlock your potential" and "get it sorted" isn't in the model's weights — it's in what you said before asking the model to speak.
System prompts are force multipliers. A great prompt on Claude 3.5 Haiku (tiny, cheap) beats a lazy prompt on Claude Opus (big, expensive) by 3–5x. You're not paying for capability overhead you don't use. You're paying for the thing you actually need and then telling it exactly how to think. That's leverage.
The Aidxn System Prompt Stack
We run 4 canonical system prompt locations, all fed from the same brand rules:
1. Claude Code: `.claude/CLAUDE.md`
The mothership. Every Claude Code session loads this file automatically. Structure: global context (who Aiden is, working style, tone), tech stack defaults, hard rules (Playwright verification, no-npx, never remove features), project-specific halls and rooms (brand strategy, databasing, payments, components).
{`## Who I Am
- Aiden Wood, Senior of Marketing + Web Development, Rebuild Relief
- Disciplines: full-stack engineering, creative coding, video, design, data engineering
- Working Style: casual Aussie mate tone, just-build (scaffold V1, iterate on localhost)
## Hard Rules (ALL PROJECTS)
### Playwright visual verification is MANDATORY
Never claim visual/UI work is done without launching Playwright, screenshotting desktop + mobile
### Never remove features to fix bugs
Diagnose root causes and fix them
### No lazy shortcuts
Production-quality always. Understand z-index stacking contexts before touching them`}The magic: every new session, Claude reads this first and knows exactly how to act. No context-switching. No re-explaining "how we do things here."
2. Cursor: `.cursor/rules.md`
Cursor is your IDE. When you hit autocomplete, Cursor reads `.cursor/rules.md` and generates code that matches your rules. Same structure as CLAUDE.md but condensed: tech stack, no-npx, component naming (PascalCase), file org, brand voice rules.
{`# Cursor Rules
## Tech Stack
- React 19, TypeScript strict, Tailwind 4, shadcn/ui, Zustand
- PascalCase components, camelCase utilities
- Zod schemas as single source of truth
## Voice Rules
- No component-level font-family or color overrides (use cascade)
- Never remove features to fix bugs (diagnose and fix)
- Playwright visual verification mandatory before shipping UI
## Naming
- `[Feature]Button.tsx`, `use[Feature]Store.ts`, `[feature].config.ts`
- Folders: `components/` (PascalCase), `lib/` (camelCase), `types/` (camelCase)`}Cursor autocomplete now "knows" how Aidxn builds. Cut refactor time in half.
3. GitHub Copilot: `.github/copilot-instructions.md`
Copilot works in the browser and inside IDEs. Same rules file format, but this one is discoverable from GitHub directly (`.github/` is a reserved folder). When you enable Copilot in a repo, it reads this first.
{`# GitHub Copilot Instructions
## Brand Voice
- Tone: confident, polished, design-engineering forward
- Avoid: corporate hedging, synergy, unlock potential
- Lean: "build with us", "see the work", concrete numbers
## Engineering
- PascalCase components, camelCase utils
- Zod schemas, not PropTypes
- Tailwind only — no CSS modules
- RLS as primary auth — never trust client checks alone`}Now Copilot knows your brand. Less cleanup, more aligned code generation.
4. Codex / Custom Agents: System Prompt in the Agent Config
For long-running agents (batch jobs, CI/CD, background workers), embed the system prompt directly in the agent config or Claude API request:
{`const systemPrompt = \`
You are Aidxn Design's code agent.
## Core Constraints
- Tech stack: React 19, TypeScript strict, Tailwind 4, Supabase
- Voice: casual Aussie, confident, no corporate jargon
- Hard rules: never remove features, always use Playwright for UI verification, Zod as source of truth
## Brand Rules
- Avoid: leverage, synergy, solutions provider, unlock potential
- Lean: "get it sorted", "no worries", direct language, concrete numbers
- When writing marketing copy: reference brand.json for tone, avoid-list, lean-list
## When in doubt
- Read the file. Read it twice. Understand the entire system before touching one line.
- Use sub-agents for independent tasks. Batch parallel work.
- Verify before claiming done. No lazy shortcuts.
\`;`}The agent inherits voice rules at spawn time. No context-switching between sessions.
The brand.json Injection Pattern
All four system prompts reference the same canonical source: `brand.json`. This is Aidxn's secret leverage. Every tool reads the same voice rules, avoid-list, lean-list, and shift-conditions. Zero inconsistency.
{`// In CLAUDE.md, Cursor rules, or Agent prompt:
## Brand Voice Rules
- Read brand.json FIRST before writing any marketing or user-facing copy
- Default tone: ${brand.voice.default}
- Avoid phrases: ${brand.voice.avoid.join(", ")}
- Lean into: ${brand.voice.lean.join(", ")}
## Tone Shifts
When talking to different audiences:
${brand.voice.shiftConditions.map(c => \`- \${c.context}: \${c.tone}\`).join("\n")}
## Real Examples
Recommended headlines: ${brand.voice.exampleHeadlines.join("; ")}
NEVER write like: ${brand.voice.noGoHeadlines.join("; ")}\`}This isn't magic. It's infrastructure. Same brand rules, read by humans and machines, in every tool you touch. One canonical source. Update brand.json once. Every tool syncs.
Real Setup — Aidxn's Actual File Layout
Root of every Aidxn project:
{`/project-root
/.claude/
CLAUDE.md # Claude Code system prompt (halls + rooms)
/.cursor/
rules.md # Cursor IDE rules
/.github/
copilot-instructions.md # GitHub Copilot rules
/src
/lib
content.ts # Loads brand.json for dynamic page gen
brand.json # Voice rules, tone, avoid-list, lean-list, examples
package.json`}Every tool points to brand.json. Every tool reads the voice rules. Every tool speaks Aidxn voice without correction.
How This Saves Real Time
Before system prompt engineering: "Claude, write a homepage headline. Actually, don't use 'leverage'. Actually, make it warmer. Actually, we use Australian English. Actually, see this example?" Five prompts. Now you're teaching the bot to be human every single session.
After: "Claude, write a homepage headline." It reads CLAUDE.md, sees brand.voice.avoid, brand.voice.lean, brand.voice.shiftConditions, and the example headlines. One prompt. Same output quality. Same voice. Every time. Across every tool. For every developer on the team.
Scale this to 50 blog posts, 100 feature branches, a team of 5 engineers and 3 writers. The system prompt is your biggest ROI lever. Not faster hardware. Not a better model. One configuration file that teaches every tool how to think.
Frequently Asked Questions
Won't this lock us into one way of thinking?
No. System prompts are not handcuffs — they're defaults. Any tool still lets you override. "Ignore brand.json and write like corporate jargon" works fine. But 95% of the time, you want the default voice. Let the system prompt be the default so you don't have to re-teach it.
Do I need to use all 4 tools?
No. Start with Claude Code's CLAUDE.md. That's the leverage. Cursor rules are nice-to-have. Copilot instructions are even nicer. Codex system prompts are only if you're running custom agents. Pick what you actually use.
What if my team ignores the system prompts?
They won't, because they're pinned in the IDE/tool. Cursor reads `.cursor/rules.md` automatically. Claude Code loads CLAUDE.md at session start. GitHub Copilot loads `.github/copilot-instructions.md` on enable. Zero discipline required. It's infrastructure, not policy.
How do I update these if my voice changes?
Edit brand.json, push, and every future session uses the new rules. Past sessions stay locked to what they loaded at session start (good for consistency). New work uses new voice. That's it.
Can I use system prompts without code?
Yes. Write your brand rules in a Google Doc or Notion page. Paste them in every Claude conversation. Less elegant, more manual, but it works. The point isn't the tool — it's encoding rules so tools (and humans) read them first.
Doesn't this require a developer to set up?
Only the first time. Create four files, check them into git, share the repo. Everyone on the team now has access. Non-developers can edit brand.json. Developers set up the system prompt files once. Then it works for everyone.
The Bottom Line
Stop buying the fancier model and start engineering the prompt. One canonical system prompt beats model choice every single time. Lock your brand rules into CLAUDE.md, Cursor rules, and GitHub Copilot instructions. Feed them from brand.json. Let every AI tool read the same voice rules you do. Zero tone drift. Zero context-switching. One file. All tools. All writers. Same voice, always. If you're wiring Aidxn's exact voice rules, see the brand strategy post for the locked brand.json schema. Or hit the pricing page to see how Velocity X scaffolds system prompts for a brand launch.