AI Coding

What separates productive AI-assisted development from expensive frustration?

Three Principles

Orchestration. You're not writing code anymore—you're directing intelligent systems. The skill shifts from syntax to clarity of intent. The moat shifts from code to data.

1. Precision Prompting

Prompting is programming. The prompt IS the spec.

• Start simple, add detail only when needed
• One clear objective per prompt
• Build a library of reusable prompt patterns
• Let the AI propose, you dispose

2. Context Control

AI wastes tokens when context is unclear. Your job: reduce ambiguity.

• Document architecture decisions where AI can read them
• Keep working context focused (one problem at a time)
• Use project rules files to encode standards
• Context switching kills momentum—batch similar work

3. Model Selection

Match capability to task. Don't use a sledgehammer for a nail.

Task	Model Choice
Quick fixes, simple generation	Fast/cheap models
Architecture, complex reasoning	Best available
Code review, refactoring	Mid-tier with long context

Invest in the best model for hard problems. Save on commodity tasks.

The Playbook

Before You Start

1. Understand the domain — Map data flows and entities before touching code
2. Identify the hard problem — What's the riskiest unknown?
3. Document constraints — What must be true? What can't change?

Project Setup

Prime your AI with persistent context:

File	Purpose
CLAUDE.md / .cursorrules	Project standards, architecture decisions
README.md	Overview, setup, conventions
docs/	Detailed specs AI can reference

During Development

1. Plan in prompts — Write specs as prompts before generating code
2. Review everything — AI writes, you verify
3. Iterate tight — Small changes, frequent checks
4. Track decisions — Document why, not just what

The Loop

SPECIFY → GENERATE → REVIEW → REFINE → COMMIT
    ↑                                    │
    └────────────────────────────────────┘

Each cycle should be small. Big prompts = big mistakes.

Automation Boundaries

Not everything should run on autopilot.

Safe for Full Auto	Requires Human Gate
Test generation, refactors	Production deploys
Docs, non-prod environments	On-chain transactions
Code review suggestions	Security-sensitive changes
Branch creation, local builds	Secrets access, compliance

The rule: Automate aggressively where mistakes are reversible. Gate ruthlessly where they're not.

Build review surfaces (diffs, dashboards, tests) so the human gate is fast but real.

Building the Moat

Code is now commodity. What compounds?

Skills — Reusable workflows that encode domain knowledge. Each execution generates feedback. The skill improves. Competitors can't copy your accumulated refinements.

Data — Proprietary action→consequence pairs. AI learns from your ground truth, not scraped noise. Clean, fast, open data feeds better predictions.

The VVFL: Skills generate data → Data trains better skills → Loop compounds.

See: Data Flow | Data Footprint

Tools

UIs are for Human Beings, Protocols are for Phygital Beings.

Tool	Best For
Claude Code	Terminal-native, deep reasoning
Cursor	IDE integration, codebase awareness
v0.dev	UI/component prototyping

Context

• Data Flow — Clean, fast, open: the properties that matter
• Data Footprint — 60-question AI readiness checklist
• Model Providers — Capabilities and tradeoffs
• Clean Architecture — Structure AI can understand

tip

Software is commodity. Your edge is culture and data.