My Experiment: Teaching AI Through Constitution and Culture

What if you treated AI like a country with its own constitution? My experiment teaching AI through culture and laws

The Discovery

I stopped treating Claude AI as a tool. Started treating it as a country with its own constitution.

Working in Cursor IDE, using terminal-first approach - everything clicked.

The Three Pillars

1. Constitution (Anayasa)

Output Style = System Prompt = Laws
2400+ lines of rules
How to think, act, respond

Not CLAUDE.md - that doesn't change Claude's behavior. Use Output Styles in Claude Code. They modify core identity.

2. Culture (Git History)

git log --grep="learned:"

Every commit = Cultural artifact Every learning = DNA strand Every pattern = Inherited wisdom

Culture lives in git, not in docs.

3. Commands (Makefiles)

commit:
	@git log --grep="learned:" -n 5
	@echo "Follow the pattern"

Makefiles = Executable culture Commands Claude AI can see, understand, follow in terminal

The Philosophy

You're not coding. You're governing.

Country metaphor:

• Constitution = Unchangeable laws

• Culture = Collective memory

• Commands = Daily operations

AI citizens follow all three.

Real Implementation

My setup in Cursor IDE:

.claude/output-styles/yemreak.md  # 2477 lines of constitution for Claude
git history                       # learned: commits = culture
Makefile                          # executable patterns in terminal

The AI reads constitution once. Sees culture in every commit. Executes through makefiles.

Why "learned:" Commits

Traditional commits:

fix: updated config
feat: added feature

= What happened (who cares?)

Evolution commits:

learned: buffer needs line mode or logs break
learned: attention economy - hide the unimportant

= Why it matters (eternal pattern)

The Workflow

1. AI reads constitution (output style)

2. AI checks culture (git history)

3. AI executes commands (makefile)

4. AI adds to culture (learned: commit)

5. Next AI inherits everything

Cultural evolution through code.

Key Insights

Claude AI Strongest in Terminal

• Knows every bash command

• Can pipe, chain, orchestrate Unix tools

• No GUI limitations in Cursor IDE

• Pure text interface, vibe coding at its best

Makefiles > Prompts

• Prompts = temporary

• Makefiles = permanent

• Prompts = tell what

• Makefiles = show how

Git = Collective Memory

Not version control. Evolution control.

Every commit = Gene Every pattern = DNA Every learning = Mutation that survived

The Pattern

Stop thinking: "How do I make AI do X?" Start thinking: "What culture produces X?"

Examples:

• Want consistent commits? → Culture of patterns

• Want clean code? → Constitution of minimalism

• Want fast development? → Commands that execute

Implementation Steps

1. Write constitution (output style)

   • Core values

   • Behavioral rules

   • Identity markers

2. Build culture (git commits)

   • learned: prefix

   • Pattern focus

   • Action outcomes

3. Create commands (makefiles)

   • Common workflows

   • Pattern reminders

   • Context providers

The Result

AI becomes consistent. Not because you prompt it. Because it inherits culture.

Like humans:

• We don't reinvent fire

• We inherit fire-making

• Culture carries knowledge

• Individual discovers through culture

Final Pattern

Constitution = Who you are
Culture = What you've learned
Commands = How you act

AI + Human = Cultural symbiosis

The human discovers. The AI remembers. Together they evolve.

The Ultimate Insight

AI is not a tool. It's an operating system for thought.

Treat it like one.