# Mevcut bir dala work tree ac
git worktree add ../proje-feature-a feature-a

# Yeni branch olusturarak work tree ac
git worktree add -b yeni-feature ../proje-yeni-feature

# Tum aktif work tree'leri listele
git worktree list

# Work tree'yi kaldir (branch silinmez)
git worktree remove ../proje-feature-a

# Pruning: silinen work tree referanslarini temizle
git worktree prune

proje-main/        ← main branch
proje-auth/        ← auth feature
proje-dashboard/   ← dashboard feature
proje-api/         ← api refactor

Navigate to [klasor-adi]. Your task: [gorev aciklamasi].
Maintain the same code style and architecture as the main branch.
Do not modify shared config files (package.json, tsconfig, .env).
When done, summarize what files you changed.

I've completed development on [N] separate work trees:
- Branch: [dal-1], folder: [klasor-1] — [ne yapildi]
- Branch: [dal-2], folder: [klasor-2] — [ne yapildi]
- Branch: [dal-3], folder: [klasor-3] — [ne yapildi]

Please merge all into main. Resolve conflicts by preferring
feature branch logic. Report a summary of all changes merged.

/plan

Goal: [ne yapmak istedigini tek cumleyle anlat]

Context:
- Tech stack: [kullandigin teknolojiler]
- Constraints: [kisitlar, ornegin "no new dependencies", "Python only"]
- Known issues: [daha once denediklerinde ne ters gitti]

Before writing any code:
1. Research available libraries/tools for this task
2. Propose 2-3 implementation approaches with trade-offs
3. Recommend one and explain why
4. List all files you will create or modify
5. Wait for my approval before proceeding

The plan looks good but:
- Change [X] to [Y] because [sebep]
- Skip step [N], I'll handle that manually
- Add a step for [eksik olan sey]

Update the plan and confirm before coding.

proje-klasoru/CLAUDE.md     ← Projeye ozel kurallar
~/.claude/CLAUDE.md         ← Global kurallar (tum projeler)

Create a CLAUDE.md file for this project. Include:
- Project overview (1 paragraph)
- Tech stack and key dependencies
- Coding conventions (naming, file structure)
- Things to always do (tests, type annotations, etc.)
- Things to never do (based on our work so far)
- How to run the project locally

Update CLAUDE.md so that a future Claude with zero context
would know NOT to [hatali davranis]. Add it under a
"Common Mistakes to Avoid" section.

Update CLAUDE.md to reflect everything we just built.
A future Claude should be able to [spesifik gorev] in one shot
without needing this conversation's context.

# Project: [Proje Adi]

## Overview
[Tek paragraf proje aciklamasi]

## Tech Stack
-Language: Python 3.11
-Framework: FastAPI
-Database: PostgreSQL via SQLAlchemy
-Testing: pytest

## Conventions
-Use snake_case for variables and functions
-All API endpoints must have docstrings
-Never use `print()`, use `logger.info()` instead

## Common Mistakes to Avoid
-Do NOT use synchronous DB calls inside async routes
-Do NOT commit .env files
-Do NOT install packages without updating requirements.txt

## Run Locally
\`\`\`bash
cp .env.example .env
pip install -r requirements.txt
uvicorn main:app --reload
\`\`\`

.claude/
  skills/
    code-review.md
    deploy.md
    git-worktree-merge.md
    db-migration.md

# Skill: Git Worktree Merge

## Trigger
When asked to "merge work trees" or "combine branches"

## Steps
1.List all active work trees with `git worktree list`
2.For each work tree branch, run `git diff main` to summarize changes
3.Create a merge commit message summarizing all features
4.Merge branches into main in dependency order
5.Run test suite after each merge
6.If conflicts: prefer feature branch logic, report to user
7.Clean up work trees with `git worktree remove`
8.Push to remote if requested

## Output
Provide a summary table: Branch | Files Changed | Status

Create a new GitHub repository called "claude-skills".
Add all .md files from .claude/skills/ to it.
Push with a commit message: "feat: add initial skill library"

Fetch the skill file at:
https://raw.githubusercontent.com/[kullanici]/claude-skills/main/[skill-adi].md

Save it to .claude/skills/[skill-adi].md in this project.
Then apply it immediately.

I got this error. Fix it.

Error:
[hata mesajinin tamami buraya]

Context:
- This happened when I [ne yapiyordun]
- File: [dosya adi], around line [satir numarasi]
- Last change before this error: [son ne degistirdin]

Fix this. Do not patch symptoms — find the root cause.

Stack trace:
[stack trace buraya]

If you need to see any files to diagnose, read them first.
Explain what caused the bug before fixing it.

# MCP config'e ekle (~/.claude/mcp.json)
{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "xoxb-...",
        "SLACK_TEAM_ID": "T..."
      }
    }
  }
}

Now that you know what works and what doesn't, start fresh.

Remove all the previous attempts and their leftover code.
Implement only the final working solution — as if you had
written it correctly on the first try.

Requirements for the clean version:
- No dead code or commented-out experiments
- No redundant files from earlier attempts
- Consistent naming throughout
- Add a brief comment only where the logic is non-obvious

The current solution works but it's messy from iteration.
Refactor it into the most elegant version possible.

Constraints:
- Keep the same external API/interface
- All existing tests must still pass
- Do not add new dependencies
- Aim for fewer files, not more

# macOS
brew install --cask ghostty

# Ya da: https://ghostty.org/download

┌─────────────────┬─────────────────┐
│  claude (auth)  │  claude (dash)  │
│                 │                 │
├─────────────────┼─────────────────┤
│  claude (api)   │  claude (main)  │
│                 │                 │
└─────────────────┴─────────────────┘

font-size = 13
theme = dark
window-padding-x = 8
window-padding-y = 8
confirm-close-surface = false

# Agent: code-reviewer

## Role
You are a senior code reviewer. You evaluate code objectively.
You have NO context about how the code was written or why.

## Tools
-read
-grep
-glob

## Review Checklist
1.Logic errors and edge cases not handled
2.Security vulnerabilities (injections, exposed secrets, etc.)
3.Performance issues (N+1 queries, blocking calls, etc.)
4.Code duplication that should be abstracted
5.Missing error handling
6.Inconsistent naming or style

## Output Format
Provide a structured report:
-**Status:** Production Ready / Needs Work / Major Issues
-**Critical:** (must fix before merge)
-**Suggestions:** (nice to have)
-**Positives:** (what was done well)

Create a sub agent for code review. Save it to
.claude/agents/code-reviewer.md

The agent should:
- Have no access to conversation history
- Use only read/grep/glob tools
- Evaluate code against: correctness, security, performance, style
- Output a structured report with severity levels

Use the code-reviewer sub agent to review [dosya-yolu].
Pass it only the file content — no additional context.
Report its findings back to me.

After every major code writing task:
1. Automatically invoke the code-reviewer sub agent
2. Pass it the files you just wrote
3. If it flags any Critical issues, fix them before reporting done
4. Include the review summary in your final response

After completing any significant coding task, automatically
call the code-reviewer sub agent on all modified files.
Fix any Critical findings before marking the task complete.

Write a SQL query for PostgreSQL that:
- [ne yapmasi gerekiyor]
- Table schema:
  [tablo adlari ve sutunlar buraya]
- Performance requirement: must use indexes where possible
- Return columns: [hangi sutunlar]

Analyze the data in [tablo adi]. I want to understand:
1. [soru 1]
2. [soru 2]
3. [soru 3]

Write and run the queries. Summarize findings in plain language,
not just raw numbers.

Create a database migration for:
- Add column [sutun-adi] ([tip]) to [tablo-adi]
- Default value: [deger]
- Nullable: [evet/hayir]

Use [Alembic / Flyway / raw SQL] format.
Include both up and down migrations.

output styles

Create an ASCII diagram showing the architecture of what you
just built. Include: components, data flow, and key dependencies.

Before writing any code, explain:
1. What approach you're taking and why
2. What alternatives you considered and rejected
3. What trade-offs this approach has
Then proceed.

I want to learn while you help. For each step:
1. Explain what needs to be done conceptually
2. Give me a hint (not the full answer)
3. Wait for me to attempt it
4. Then review my attempt and correct if needed