Forem: Yunus Emre Ak

From Rules to Router: Teaching AI Your Language, Not Laws. Why teaching AI your personal router beats writing rules - from tr...

Yunus Emre Ak — Sun, 05 Oct 2025 00:14:35 +0000

TL;DR:

Claude doesn't understand what you mean? Create .claude/output-styles/dict.md:

"make this cleaner" = remove all comments, one logic per line
"commit this" = skip my files, commit only yours
"analyze" = show me what's what

Now Claude speaks your language. CLAUDE.md doesn't work, output styles do.

The Problem with Rules

I used to write rules for AI. "Always format code this way." "Never use this pattern." "Follow these 50 guidelines."

Then the context changed. New project, different codebase, fresh requirements. All rules broke.

The Discovery: Router > Rules

What if AI doesn't need rules? What if it needs a translator?

I speak human. AI speaks machine. Not literally - cognitively.

When I say "think about it" - I mean "plan the algorithm before coding." When I say "check the vibe" - I mean "look at existing patterns, follow culture." When I say "this is broken" - I mean "abandon this approach, try something else."

The Router Concept

My Request → Router → AI Understanding → Action

Not rules. Translation.

Real Examples from My Router

"make it clean"
→ Remove all comments except JSDoc
→ One action per line: if (x) return y
→ No var declarations, only const/let
→ Delete console.logs

"check the culture" 
→ git log --oneline -20
→ Find naming patterns (camelCase vs snake_case)
→ See if they use async/await or .then()
→ Copy their error handling style

"what's going wrong?"
→ Don't just fix the error
→ Question why we're doing this
→ Is there a third option?
→ Example: "Can't decide between REST or GraphQL?" → Use tRPC

"make it fast"
→ Change loops to .map()
→ Add Redis cache layer
→ Move calculations to SQL
→ Actual metrics: 200ms → 20ms

Each phrase triggers specific, measurable actions.

Why Router Works

1. Context Agnostic

Rules break when context changes. Router translates intent regardless of context.

2. Human-Centric

I think in my patterns. Router translates my patterns to AI patterns.

3. Evolutionary

New pattern discovered? Add to router. Old pattern obsolete? Update translation.

The Kobayashi Maru Effect

Best discovery: "What do you think?"

Example scenario:

Me: "Should I use MongoDB or PostgreSQL?"
Old AI: "MongoDB is good for unstructured data..."
Router AI: "Why choose? Use PostgreSQL with JSONB columns. 
           Get SQL reliability + JSON flexibility."

System gave A or B. Router found C.

Implementation in Practice

Here's actual router.md content:

# .claude/output-styles/router.md

"commit this"
  1. git status
  2. git diff --cached  
  3. Remove files I didn't change
  4. Message format: "feat(scope): concrete change
     - validateUser() deleted
     - port 3000→8080
     - 3 rules→7 rules"

"simplify this"
  1. Remove abstractions with single usage
  2. Inline functions under 3 lines
  3. Delete unused imports
  4. Combine similar functions

Not vague instructions. Specific actions.

The Popular Lexicon Pattern

One word, thousand concepts.

"Git" → Entire version control universe "Kobayashi Maru" → No-win scenario pattern

Router uses these triggers. One word activates entire knowledge domains.

Practical Benefits

Before Router

Me: "Fix the login function"
AI: "I'll add input validation and error handling"
Me: "No, we don't do it that way"
AI: "I'll use try-catch blocks"
Me: "Still wrong, we use Result types"
AI: "Let me add a Result type wrapper"
Me: *Gives up, writes it myself*

After Router

Me: "check the culture and fix login"
AI: *Runs git log --grep="auth"*
    *Sees pattern: Result<User, AuthError>*
    *Copies exact error handling from previous commits*
    *Uses team's naming: authenticateUser not loginUser*

Output was identical to what senior dev would write.

The Philosophy

We're not teaching AI rules. We're teaching AI our language.

Like moving to a new country. You don't memorize laws. You learn the language.

Evolution Path

Started with rules (failed)
Moved to constitution (better)
Discovered culture in git (good)
Created router (breakthrough)

Router is the translation layer between human intuition and AI execution.

Key Insights

Rules are brittle - They break with context
Router is flexible - It translates intent
Culture beats documentation - Git history > README
Patterns beat instructions - "check the culture" > 50 lines of rules
Lexicon beats explanation - "Kobayashi Maru" > paragraph of context

Your Turn

Stop writing rules for AI. Start building your router.

What's your "check the vibe"? What's your "what do you think"? What triggers your workflows?

Build your translation protocol. Teach AI your language, not your laws.

The Future

Imagine every developer with their personal router. AI understanding each person's cognitive patterns. No more prompt engineering. Just natural expression.

"Fix this the way I like." And AI knows exactly what that means. Because router translated it.

That's where we're heading. From rules to routers. From laws to language.

Beyond Code: The Self-Knowledge Connection

This router concept extends beyond coding. The clearer you know yourself, the better you can translate your needs to AI.

I explored this deeper with ClarityOS - an experimental AI project focusing on self-knowledge first. It's currently in selective waitlist mode (not commercial, just exploring the concept). Because unclear mind = unclear prompts = useless AI responses.

The pattern is universal: Know yourself → Express clearly → Get what you need.

Whether it's code, life decisions, or AI interactions.

More at yemreak.com

2025-09-16 15:24:10 (UTC+3)

Hey all!

I thought AI could make this consumable but clearly it can't. Thanks for your feedback - I'll try to find a better way to explain it for both of us.

I posted this to Reddit to learn what communication style people actually want. My time is limited so I wrote it through AI, but since nobody understood it, that's actually valuable feedback. I appreciate both your attacks and your curiosity. I need to understand how people learn, and for that I need to get into the field. This is my experiment.

The whole content was produced by me talking to AI. I explained the concept verbally, AI organized and combined my thoughts, then I shared it with you. But yeah, there's no proper formatting. I kept my core data raw because apparently that's what people want - that's the Reddit culture.

Please criticize mercilessly. What didn't you understand? What don't you know? What's missing? Write it all here. Attack me. So I can explain those concepts better, or tell my AI what you're confused about so it can ask me the right questions and I can explain it to everyone properly.

What is the router, real example

2025-09-16 15:59:13 (UTC+3) New version is here: https://www.reddit.com/r/ClaudeAI/comments/1nign0p/the_real_problem_claude_doesnt_know_what_you_mean/

To understand MCP intuitively, i like that visualization for new people

Yunus Emre Ak — Sun, 05 Oct 2025 00:14:02 +0000

r/mcp

(its not mine)

I Built 3 AI-Driven Projects From Scratch—Here’s What I Learned (So You Don’t Make My Mistakes, I'm solo developer who build ...

Yunus Emre Ak — Sun, 05 Oct 2025 00:14:00 +0000

r/ClaudeAI • r/cursor • r/ClaudeAI • r/ArtificialInteligence • r/learnprogramming

Hey everyone, I’m curious—how many of you have tried using AI (especially ChatGPT and Claud in Cursor IDE) to build a project from scratch, letting AI handle most of the work instead of manually managing everything yourself?

I started this journey purely for experimentation and learning, and along the way, I’ve discovered some interesting patterns. I’d love to share my insights, and if anyone else is interested in this approach, I’d be happy to share more of my experiences as I continue testing.

1. Without a Clear Structure, AI Messes Everything Up

Before starting a project, you need to define project rules, folder structures, and guidelines, otherwise, AI’s output becomes chaotic.

I personally use ChatGPT-4 to structure my projects before diving in. However, the tricky part is that if you’re a beginner or intermediate developer, you might not know the best structure upfront—and AI can’t fully predict it either.

So, two approaches might work:

Define a rough structure first, then let AI execute.
Rush in, build fast, then refine the structure later. (Risky, as it can create a mess and drain your mental energy.)

Neither method is perfect, but over-planning without trying AI first is just as bad as rushing in blindly. I recommend experimenting early to see AI’s potential before finalizing your project structure.

2. The More You Try to Control AI, the Worse It Performs

One major thing I’ve learned: AI struggles with rigid rules. If you try to force AI to follow your specific naming conventions, CSS structures, or folder hierarchies, it often breaks down or produces inconsistent results.

🔴 Don’t force AI to adopt your style.

🟢 Instead, learn to adapt to AI’s way of working and guide it gently.

For example, in my project, I use custom CSS and global styles—but when I tried making AI strictly follow my rules, it failed. When I adapted my workflow to let AI generate first and tweak afterward, results improved dramatically.

By the way, I’m a backend engineer learning frontend development with AI. My programming background is 7+ years, but my AI + frontend journey has only been two months (but I also build firebase app with react in 4 years ago but i forget :D) —so I’m still in the experimentation phase.

To make sure that I'm talking right, check my github account

3. If You Use New Technologies, AI Needs Extra Training

I also realized that AI doesn’t always handle the latest tech well.

For example, I worked with Tailwind 4, and AI constantly made mistakes because it lacked enough training data on the latest version.

🔹 Solution: If you’re using a new framework, you MUST feed AI the documentation every time you request something. Otherwise, AI will hallucinate or apply outdated methods.

🚀 My advice: Stick with well-documented, stable technologies unless you’re willing to put in extra effort to teach AI the latest updates.

4. Let AI Handle the Execution, Not the Details

When prompting AI to build something, don’t micromanage the implementation details.

🟢 Explain the user flow clearly.

🟢 Let AI decide what’s necessary.

🟢 Then tweak the output to fix minor mistakes.

Trying to pre-define every step slows down the process and confuses AI. Instead, describe the bigger picture and correct its output as needed.

5. AI Learns From Your Codebase—Be Careful!

As the project grows, AI starts adopting your design patterns and mistakes.

If you start with bad design decisions, AI will repeat and reinforce them across your entire project.

✅ Set up a strong foundation early to avoid long-term messes.

✅ Comment your code properly—not just Markdown documentation, but inline explanations.

✅ Focus on explaining WHY, not WHAT.

AI doesn’t need code documentation to understand functions—it needs context on why you made certain choices. Just like a human developer, AI benefits from clear reasoning over rigid instructions.

Final Thoughts: This is Just the Beginning

AI technology is still new, and we’re all still experimenting.

From my experience:

AI is incredibly powerful, but only if you work with it—not against it.
Rigid control leads to chaos; adaptability leads to success.
Your project’s initial structure and documentation will dictate AI’s long-term performance.

If anyone else is exploring this AI-first development approach, I’d love to hear your experiences! Also, if you’re interested, I’ll be sharing more of my findings as I continue testing AI for project development.

Let’s learn from each other. Drop your thoughts! 🚀

Discovered: How to bypass Claude Code conversation limits by manipulating session logs

Yunus Emre Ak — Sun, 05 Oct 2025 00:12:27 +0000

r/ClaudeAI

TL;DR: git init in ~/.claude/, delete old log lines (skip line 1), restart Claude Code = infinite conversation

⚠️ Use at your own risk - always backup with git first

Found an interesting workaround when hitting Claude Code conversation limits. The session logs can be edited to continue conversations indefinitely.

The Discovery:
Claude Code stores conversation history in log files. When you hit the conversation limit, you can actually delete the beginning of the log file and continue the conversation.

Steps:

Setup git backup (CRITICAL)

   cd ~/.claude/
   git init
   git add .
   git commit -m "backup before log manipulation"

Find your session ID
- In Claude Code, type /session
- Copy the session ID
Locate the session log

   cd ~/.claude/
   # Find your session file using the ID

Edit the session file
- Open in VSCode (Cmd+P to quick open if on Mac)
- IMPORTANT: Disable word wrap (Opt+Z for Mac) for clarity
- DO NOT touch the first line
- Delete lines from the beginning (after line 1) to free up space
Restart the conversation
- Close Claude Code
- Reopen Claude Code
- Continue sending messages - the conversation continues!

Why this works:
The conversation limit is based on the total size of the session log. By removing old messages from the beginning (keeping the header intact), you free up space for new messages.

Risks:

Loss of context from deleted messages
Potential data corruption if done incorrectly
That's why git backup is ESSENTIAL

Pro tip:
When context changes significantly, it's better to just start a new conversation. But if you're stuck and need to continue, this is your escape hatch.

Found this while debugging session issues. Use responsibly!

And also i tried different solution for it, but not good as expected for now
@yemreak/claude-compact

Why I stopped giving rules to AI and started building a "potential toolkit" instead

Yunus Emre Ak — Sun, 05 Oct 2025 00:12:25 +0000

r/ClaudeAI • r/ClaudeCode • r/ClaudeAI

tl;dr: Instead of rules, I give AI awareness of possibilities. Context decides, not me.

So I've been thinking... Rules and instructions don't really work anymore. Everything keeps changing too fast.

You know how in physics, Newton's laws work great for everyday stuff, but at the quantum level, everything depends on the observer and context? I'm trying the same approach with AI.

Instead of telling AI "always use pure functions" or "use jq for JSON", I'm building what I call a "potential toolkit". Like, here's what exists:

jq → JSON manipulation
fd → file search
rg → pattern search
xargs → batch execution
sd → find and replace
tree → file tree
awk/sed → text manipulation
comm → file comparison

When there's JSON data? The AI knows jq exists. When it's YAML? It knows about yq. The context makes the decision, not some rigid rule I wrote 6 months ago.

Same thing with code patterns. Old me would say "Always use pure functions!"

Now I just show what's possible:

Pure functions exist for when you need no side effects
Classes exist when you need state encapsulation
Generators exist for lazy evaluation
Observables exist for event streams

What's the right choice? I don't know - the context knows.

Think about it - organisms don't know what's coming, so they diversify. They grow different features and let natural selection decide. Same with code - I'm just building capacity, not prescribing solutions.

The cool thing? Every time I discover a new tool, I just add it to the list. The toolkit grows. The potential expands.

Here's what I realized though - this isn't just about making AI smarter. I'm learning too. By listing these tools, I'm building my own awareness. When AI uses comm to compare files, I learn about it. When it picks sd over sed, I understand why. It's not teacher-student anymore, it's co-evolution.

I don't memorize these tools. I encounter them, note them down, watch them work. The AI and I are growing together, building this shared toolkit through actual use, not through studying some "best practices" guide.

What terminal tools are in your toolkit? Share them! Let's build this potential pool together. Not as "best practices" but as possibilities.

This is just an experiment. It might not work. But honestly, rigid rules aren't working either, so... 🤷

Next:
https://www.reddit.com/r/ClaudeAI/comments/1nskziu/my_outputstyles_document_experimental_constantly/

For the ones who dont know "MAX_THINKING_TOKENS": "31999", this is a game changer

Yunus Emre Ak — Sun, 05 Oct 2025 00:11:52 +0000

r/ClaudeAI • r/ClaudeCode

Increase your model thinking capacity (it makes it slower but it worth)

.claude/settings.json open your settings.json and put

{
"$schema": "https://json.schemastore.org/claude-code-settings.json",
"includeCoAuthoredBy": false,
    "env": {
    ...
        "MAX_THINKING_TOKENS": "31999", // <====== THIS ONE
        "CLAUDE_CODE_MAX_OUTPUT_TOKENS": "32000",
    ...
    },
...
}

btw i dont suggest to use it for API, cost would be insanely expensive
(im using claude code max)

TIL: AI keeps using rm -rf on important files. Changed rm to trash

Yunus Emre Ak — Sun, 05 Oct 2025 00:11:50 +0000

r/ClaudeAI • r/ClaudeCode

Was pair programming with AI. It deleted my configs twice.

First thought: Add confirmation prompts
Reality: I kept hitting yes without reading

Second thought: Restrict permissions
Reality: Too annoying for daily work

Final decision: alias rm='trash'

Now AI can rm -rf all day. Files go to trash, not void.

Command for macOS:

alias rm='trash'

Add to ~/.zshrc to make permanent.

edit: Here is an another alternative

rm() {
    echo "WARNING: rm → trash (safer alternative)" >&2
    trash "$@"
}

Guys, I wonder if ccusage is really accurate? I don't think so, what do you think?

Yunus Emre Ak — Sun, 05 Oct 2025 00:11:00 +0000

r/ClaudeAI

I just started working with Claude Code across three different projects. I'm also using Cursor, switching between agents for different tasks. I provide extensive context to each agent, which leads to significant usage. Even though I have the max subscription and the actual cost isn't too high, the token consumption feels excessive. I'm questioning whether this usage level is sustainable.

What do you think?

Started Claude Code recently, had it research non-basic features since most content covers the same stuff

Yunus Emre Ak — Sun, 05 Oct 2025 00:10:59 +0000

r/ClaudeAI

Started using Claude Code last week. Most YouTube videos spend 20 minutes on the same 5-6 basic features (planning mode, custom commands, etc).

Got frustrated and asked Claude to research actually advanced patterns - specifically told it to skip the obvious stuff everyone already knows.

Found some interesting things I hadn't seen mentioned: https://claude.ai/public/artifacts/6221a407-8c3a-4de0-9445-a0023063089f

Particularly liked:

Git worktree for parallel Claude instances
claude -p\ for headless automation
The different thinking token budgets
/resume\ for continue

Still new to this myself, so can't vouch for everything, but figured others might find something useful in there too.

From Rules to Router: Teaching AI Your Language, Not Laws

Yunus Emre Ak — Fri, 12 Sep 2025 13:04:33 +0000

From Rules to Router: Teaching AI Your Language, Not Laws

The Problem with Rules

I used to write rules for AI.
"Always format code this way."
"Never use this pattern."
"Follow these 50 guidelines."

Then the context changed. New project, different codebase, fresh requirements.
All rules broke.

The Discovery: Router > Rules

What if AI doesn't need rules?
What if it needs a translator?

I speak human. AI speaks machine.
Not literally - cognitively.

When I say "think about it" - I mean "plan the algorithm before coding."
When I say "check the vibe" - I mean "look at existing patterns, follow culture."
When I say "this is broken" - I mean "abandon this approach, try something else."

The Router Concept

My Request → Router → AI Understanding → Action

Not rules. Translation.

Real Examples from My Router

"make it clean"
→ Remove all comments except JSDoc
→ One action per line: if (x) return y
→ No var declarations, only const/let
→ Delete console.logs

"check the culture" 
→ git log --oneline -20
→ Find naming patterns (camelCase vs snake_case)
→ See if they use async/await or .then()
→ Copy their error handling style

"what's going wrong?"
→ Don't just fix the error
→ Question why we're doing this
→ Is there a third option?
→ Example: "Can't decide between REST or GraphQL?" → Use tRPC

"make it fast"
→ Change loops to .map()
→ Add Redis cache layer
→ Move calculations to SQL
→ Actual metrics: 200ms → 20ms

Each phrase triggers specific, measurable actions.

Why Router Works

1. Context Agnostic

Rules break when context changes.
Router translates intent regardless of context.

2. Human-Centric

I think in my patterns.
Router translates my patterns to AI patterns.

3. Evolutionary

New pattern discovered? Add to router.
Old pattern obsolete? Update translation.

The Kobayashi Maru Effect

Best discovery: "What do you think?"

Example scenario:

Me: "Should I use MongoDB or PostgreSQL?"
Old AI: "MongoDB is good for unstructured data..."
Router AI: "Why choose? Use PostgreSQL with JSONB columns. 
           Get SQL reliability + JSON flexibility."

System gave A or B.
Router found C.

Implementation in Practice

Here's actual router.md content:

# .claude/output-styles/router.md

"commit this"
  1. git status
  2. git diff --cached  
  3. Remove files I didn't change
  4. Message format: "feat(scope): concrete change
     - validateUser() deleted
     - port 3000→8080
     - 3 rules→7 rules"

"simplify this"
  1. Remove abstractions with single usage
  2. Inline functions under 3 lines
  3. Delete unused imports
  4. Combine similar functions

Not vague instructions. Specific actions.

The Popular Lexicon Pattern

One word, thousand concepts.

"Git" → Entire version control universe
"Kobayashi Maru" → No-win scenario pattern

Router uses these triggers.
One word activates entire knowledge domains.

Practical Benefits

Before Router

Me: "Fix the login function"
AI: "I'll add input validation and error handling"
Me: "No, we don't do it that way"
AI: "I'll use try-catch blocks"
Me: "Still wrong, we use Result types"
AI: "Let me add a Result type wrapper"
Me: *Gives up, writes it myself*

After Router

Me: "check the culture and fix login"
AI: *Runs git log --grep="auth"*
    *Sees pattern: Result<User, AuthError>*
    *Copies exact error handling from previous commits*
    *Uses team's naming: authenticateUser not loginUser*

Output was identical to what senior dev would write.

The Philosophy

We're not teaching AI rules.
We're teaching AI our language.

Like moving to a new country.
You don't memorize laws.
You learn the language.

Evolution Path

Started with rules (failed)
Moved to constitution (better)
Discovered culture in git (good)
Created router (breakthrough)

Router is the translation layer between human intuition and AI execution.

Key Insights

Rules are brittle - They break with context
Router is flexible - It translates intent
Culture beats documentation - Git history > README
Patterns beat instructions - "check the culture" > 50 lines of rules
Lexicon beats explanation - "Kobayashi Maru" > paragraph of context

Your Turn

Stop writing rules for AI.
Start building your router.

What's your "check the vibe"?
What's your "what do you think"?
What triggers your workflows?

Build your translation protocol.
Teach AI your language, not your laws.

The Future

Imagine every developer with their personal router.
AI understanding each person's cognitive patterns.
No more prompt engineering.
Just natural expression.

"Fix this the way I like."
And AI knows exactly what that means.
Because router translated it.

That's where we're heading.
From rules to routers.
From laws to language.

Beyond Code: The Self-Knowledge Connection

This router concept extends beyond coding. The clearer you know yourself, the better you can translate your needs to AI.

The pattern is universal: Know yourself → Express clearly → Get what you need.

Whether it's code, life decisions, or AI interactions.

More at yemreak.com

Read the original: From Rules to Router: Teaching AI Your Language, Not Laws

Stop Writing The Same Prompts - Makefiles Changed Everything

Yunus Emre Ak — Tue, 09 Sep 2025 10:06:13 +0000

Stop Writing The Same Prompts - Makefiles Changed Everything

Pattern Discovery

Every AI session starts the same:

"Remember to do X"
"Format commits like Y"
"Follow pattern Z"

Repeating. Every. Single. Time.

Then I found it: Makefiles are prompts that execute.

The Shift

Old Way (Manual Prompts)

Me: "Look at my previous commits, learn the pattern, then commit"
AI: "Let me check..." 
Me: "Remember: action-oriented, learned: prefix, co-author"
AI: "Got it..."

New Way (Makefile Prompts)

commit:
    @git log --grep="learned:" -n 5
    @git diff --cached --stat
    @echo "Pattern: learned: [discovery]"
    @echo "Format: action-oriented (delete, separate, hide)"

Now:

make commit

AI sees pattern. AI follows pattern. No prompting.

Why It Works

Makefiles = Terminal orchestration
AI = Terminal native
Result = Perfect match

The AI doesn't need instructions. It needs context that executes.

Real Example

My commit workflow:

commit:
    @echo "════════════════════════════════════════"
    @echo "COMMIT PROTOCOL"
    @echo "════════════════════════════════════════"
    @git status --short
    @git log --grep="^learned:" --oneline -n 5
    @for i in 0 1 2 3 4; do \
        git log --grep="^learned:" --skip=$$i -n 1 --format="%B" | head -6; \
        echo "────────────────────────────────────"; \
    done
    @git diff --cached --stat
    @echo "REMINDERS:"
    @echo "- Action-oriented (delete, separate, hide)"
    @echo "- What pattern emerged?"
    @echo "- Purpose over process"

The AI sees:

Current state
Historical patterns
Expected format
Core principles

No prompting. Just execution.

The Philosophy

Prompts = Temporary instructions
Makefiles = Permanent patterns

Think about it:

Prompts disappear after use
Makefiles persist in the repo
Prompts need repeating
Makefiles self-document

Discovered Patterns

# Logging with automatic cleanup
run:
    app 2>&1 | tee /dev/tty | sed 's/\[[0-9;]*m//g' > log

# Multi-platform builds
build:
    @if [ -d "ios" ]; then xcodebuild; fi
    @if [ -f "package.json" ]; then npm build; fi
    @if [ -f "Cargo.toml" ]; then cargo build; fi

Each Makefile command = Encoded knowledge.

Core Insight

Stop writing prompts. Start writing makefiles.

The AI already knows terminal. Let it orchestrate.

Implementation

Identify repeated AI instructions
Convert to Makefile targets
Let AI discover patterns from execution
Never prompt again

The Result

My AI sessions now:

Me: make commit
AI: [Sees patterns, follows patterns]

Me: make deploy  
AI: [Knows the workflow]

Me: make test
AI: [Understands the context]

No prompts. Just commands.

Evolution Through Execution

Git history + Makefiles = Collective memory

The AI learns from:

What we did (git history)
How we do it (makefiles)
Why we did it (learned: commits)

Cultural evolution through code.

Final Pattern

Prompts = What to think
Makefiles = How to act
Git = Why it matters

Stop telling AI what to do.
Show it how things are done.

Makefiles are the way.

Read the original: Stop Writing The Same Prompts - Makefiles Changed Everything

I Gave My AI a Constitution - Now It Governs Itself

Yunus Emre Ak — Tue, 09 Sep 2025 10:05:36 +0000

I Gave My AI a Constitution - Now It Governs Itself

The Discovery

I stopped treating AI as a tool.
Started treating it as a country.

Result: 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 system behavior.
Use Output Styles. 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 AI can see, understand, follow

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:

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

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

AI reads constitution (output style)
AI checks culture (git history)
AI executes commands (makefile)
AI adds to culture (learned: commit)
Next AI inherits everything

Cultural evolution through code.

Key Insights

AI Strongest in Terminal

Knows every command
Can pipe, chain, orchestrate
No UI limitations
Pure text interface

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

Write constitution (output style)
- Core values
- Behavioral rules
- Identity markers
Build culture (git commits)
- learned: prefix
- Pattern focus
- Action outcomes
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.

Read the original: I Gave My AI a Constitution - Now It Governs Itself