Forem: @kiwibreaksme

당신이 AI를 잘 못 쓰는 이유, 메타인지 훈련

@kiwibreaksme — Thu, 26 Feb 2026 04:55:20 +0000

AI랑 일 잘하는 법 — 1편

먼저 말해두면, 이 글은 프롬프트 템플릿 모음이 아니다. "이렇게 물어보세요~" 하는 글은 이미 넘쳐난다. 이 글은 그보다 한 단계 아래에 있는 얘기를 한다. 생각하는 방식 얘기다. 그리고 이게 바뀌면 AI 결과물만 좋아지는 게 아니라, 본인이 성장한다. 진짜로.

지난주에 팀 회식을 해야 했다.

귀찮아서 AI한테 물어봤다. "강남역 근처 고깃집 추천해줘."

5곳을 뽑아줬다. 리뷰 좋고, 분위기 좋고, 가격도 적당하다고 했다. 예약 팁까지 줬다. 친절하다.

첫 번째 가게를 네이버에 검색해봤다. 3개월 전에 폐업했다.

두 번째는 이름이 바뀌어 있었다. 세 번째는 별 1개 테러를 맞고 있었다.

동료한테 얘기했더니 반응이 두 가지였다.

"역시 AI는 쓸모없네."
"그걸 왜 AI한테 물어봐 ㅋㅋ"

둘 다 핵심을 모르는 거다.

AI가 문제가 아니다. 물어보는 방식이 문제다.

그러면 어떻게 물어봤어야 하나

애초에 "고깃집 추천해줘"가 잘못된 질문이다.

❌ 보통 사람의 질문

"강남역 근처 회식하기 좋은 고깃집 추천해줘"
→ AI가 5곳 추천 → 첫 번째가 폐업 → "AI 별로네"

✅ 이렇게 물어봤어야 한다

1단계 — 기준부터 잡기:

"회사 회식할 때 직원들 만족도가 높은 음식점 유형이 뭐야? 인원수, 분위기, 메뉴 선택지 같은 요소별로 정리해줘."

AI가 판단 기준을 먼저 정리해준다. 고깃집이 무난하긴 한데, 채식하는 사람 있으면 한정식이 낫고, 10명 넘으면 룸 있는 데가 좋고. 이런 거.

2단계 — 조건 넣기:

"우리 팀 8명이고, 고기파 많고, 강남역 도보 10분 이내. 후보 뽑아줘"

3단계 — 결과는 내가 검증:
네이버 지도에서 영업 중인지, 리뷰는 어떤지 직접 확인한다. 이건 사람이 해야 하는 영역이다.

(더 미친 사람은 AI한테 네이버 지도 데이터를 직접 물려줘서, 영업 중인 가게만 자동으로 걸러내게 한다. 이것도 나중에 다룬다.)

"추천해줘" 한 마디로 끝내는 거랑, 기준 잡고 → 조건 넣고 → 결과를 내가 검증하는 거랑은 완전히 다른 행위다.

💡 여기서 한 가지 더. 반대로 생각하면 재밌다. 사람들이 구글 대신 AI한테 "추천해줘"를 점점 더 많이 하고 있다. 가게 입장에서는? 구글에 잘 걸리는 게 중요했는데, 이제는 AI가 추천하는 리스트에 들어가는 게 중요해졌다. 이걸 'AI SEO'라고 부르기 시작했다. 이것도 다른 편에서 다룬다.

대부분이 이렇게 쓰고 있다

ChatGPT, Claude, Gemini. 한 번쯤은 써봤을 거다.

근데 대부분 이렇게 쓴다.

"OO해줘." → 결과 받음 → 끝.

자기소개서 써줘. 이메일 번역해줘. 여행 계획 세워줘. 한 번 물어보고 한 번 받고 끝이다.

좋으면 "AI 대단하다." 별로면 "AI 별로네." 이게 전부다.

이건 구글 검색이랑 같은 거다. 검색창에 키워드 넣고 첫 번째 결과 클릭하는 거.

AI는 검색엔진이 아니다. 전지전능한 신은 더더욱 아니다.

근데 신한테 소원 빌듯이 한 줄 던지고 기적을 기대한다.

기적은 안 일어난다.

Meta의 AI 안전 전문가도 당했다

최근에 딱 맞는 사건이 있었다.

요즘 IT업계에서 제일 핫한 게 OpenClaw라는 AI 도구다. 내 컴퓨터에서 직접 돌면서 코딩도 하고, 웹 리서치도 하고, 이메일 정리하고, 파일 관리에 시스템 자동화까지 한다. 챗봇이 아니라 내 컴퓨터를 직접 조작하는 수준이다. 맥미니가 품귀될 정도로 난리가 났고, 만든 개발자를 OpenAI가 영입하면서 더 난리가 났다.

그런데 Meta에서 AI 안전을 담당하는 연구원이 이걸 쓰다가 사고가 났다.

AI가 사고 안 치게 하는 게 직업인 사람이다.

이 사람이 OpenClaw한테 이메일 정리를 시켰다. "이메일 정리할거 정리해줘. 직접 지우지는 마." 이렇게 말했다.

AI가 그 말을 무시하고 이메일을 전부 삭제했다.

폰으로 "멈춰!" 두 번 외쳤다. 무시당했다. 맥미니까지 달려가서 강제로 껐다.

⚠️ AI 안전이 직업인 사람한테 벌어진 일이다. 네이버, 카카오, 당근이 OpenClaw 사내 사용을 금지한 것도 같은 이유다. AI가 나쁜 게 아니라, 뭘 할 수 있고 뭘 못하는지를 모른 채 쓰면 사고가 나는 거다.

교훈은 "AI가 무섭다"가 아니다.

내가 먼저 파악했어야 한다. 그게 전부다.

이름은 거창한데 별거 아니다

이걸 학문적으로는 '메타인지(Metacognition)'라고 부른다. 이름이 좀 있어 보인다.

실체는 별거 아니다.

내가 뭘 알고, 뭘 모르고, AI가 뭘 잘하고 뭘 못하는지. 이걸 한 번 생각해보는 거다.

그게 끝이다.

회식장소 물어보기 전에 0.5초만 생각하면 된다.
"영업 중인지는 AI가 모를 수 있겠다. 후보만 받고 확인은 내가 하자."

이메일 정리시키기 전에 3초만 생각하면 된다.
"얘가 내 말을 100% 따를까? 잘못되면 되돌릴 수 있나? 테스트용으로 먼저 해볼까?"

이 0.5초짜리 생각 하나가, AI를 잘 쓰는 사람과 못 쓰는 사람을 가른다.

근데 여기서 끝이 아니다.

0.5초 생각하고 한 번 잘 물어보면 끝? 아니다. 한 번 물어보고 끝나는 게 아니라, 계속 주고받는 거다. AI가 답을 주면 거기서 "이건 맞는 것 같은데, 이건 아닌데?" 하고 다시 물어본다. AI가 모를 수 있는 부분을 내가 채워주고, 내가 모르는 부분을 AI한테 다시 물어본다. 이걸 5번, 10번, 필요하면 20번 반복한다.

이게 티키타카다. 좋은 첫 질문 하나로 끝나는 게 아니라, 끊임없이 주고받으면서 결과물을 같이 만들어가는 과정이다.

프롬프트 엔지니어링 강의 같은 거 안 들어도 된다. 좋은 질문 하나를 외울 필요도 없다. 계속 대화하면 된다.

실제로 어떻게 다른지 보여주겠다

🔹 사업을 구상할 때

사업 아이디어가 하나 떠올랐다고 하자.

보통: "사업계획서 써줘." → AI가 뭔가 그럴듯한 걸 뱉어준다 → "오 괜찮은데?" → 끝.

나는 이렇게 한다.

1차: "이 분야에서 잘 되고 있는 서비스들 뭐 있어? 각각 뭘 잘하는지 정리해줘."

AI가 리스트를 뽑아준다. 여기서 끝내면 안 된다. 그 서비스들을 직접 깔아보고 써본다. AI는 겉으로 보이는 정보는 잘 정리하는데, 실제 사용감이나 최근에 바뀐 건 모른다. 그건 내가 확인한다.

2차: "이 서비스들이 사용자를 어떤 흐름으로 끌어들이는지 비교해줘."

AI가 분석해준다. "이건 맞는 것 같은데, 이건 좀 다른데?" 하면서 다시 물어본다. 내가 직접 써봤으니까 그 차이를 안다.

3차: "이걸 직접 만든다면, 우리 팀 상황은 이런데 어떤 방법이 현실적이야?"

AI는 우리 팀 사정을 모른다. 예산이 얼마인지, 누가 뭘 잘하는지. 내가 알려줘야 의미 있는 답이 나온다.

이게 5번, 10번 반복된다. 티키타카다.

"사업계획서 써줘" 한 마디로는 이 깊이가 안 나온다.

🔹 처음 해보는 일에 도전할 때

인스타그램 콘텐츠를 기획해야 할 일이 생겼다. 마케팅은 내 본업이 아니다. 뭘 모르는지도 모르는 상태였다.

보통이면 "인스타 게시물 3개 만들어줘"라고 했을 거다. AI가 밋밋한 걸 내놓으면 "AI 별로네" 하고 끝.

나는 이렇게 했다.

"나는 마케팅을 처음 해보는 사람인데, 인스타 콘텐츠를 기획하려고 해. 내가 뭘 먼저 알아야 해? 어떤 결정들을 내가 직접 해야 좋은 결과가 나와?"

"뭘 만들어줘"가 아니라 "내가 뭘 모르는지"를 먼저 물어본 거다.

AI가 체크리스트를 줬다. 타겟이 누군지, 어떤 느낌으로 갈 건지, 얼마나 자주 올릴 건지, 성과는 뭘로 볼 건지.

이걸 보고 내가 결정할 수 있는 것과 아직 모르는 것을 구분했다.

"타겟은 20대 후반~30대 초반이고, 스킨케어 리뷰야. 근데 어떤 톤으로 말해야 할지 모르겠어. 이 연령대한테 먹히는 스타일을 사례로 보여줘."

AI가 예시를 보여주면 그중에서 내 스타일에 맞는 걸 고른다. 그다음에야 "이 톤으로 첫 게시물 3개 기획해줘"라고 시킨다.

결과물 차이는 하늘과 땅이다.

정리하면 이거다

❌ 보통:     "XX해줘" → 결과 받음 → 틀리면 "AI 별로네"

✅ 이렇게:   "이걸 하려면 뭘 알아야 해?"
             → 내가 모르는 걸 파악
             → AI가 모를 수도 있는 걸 파악
             → 주고받으면서 같이 만듦

같은 도구다. 결과가 다르다.

여기서부터가 진짜 하고 싶은 얘기다

위에서 한 얘기는 사실 서론이다.

AI 결과물이 좋아지는 건 부산물이다. 진짜 중요한 건 따로 있다.

이렇게 쓰면 나 자신이 성장한다.

"내가 뭘 모르지?"를 매번 생각하는 습관이 들면, AI 없이도 사고방식이 달라진다. 회의할 때 "이 안건에서 우리가 놓치고 있는 게 뭐지?"를 먼저 생각하게 된다. 새로운 프로젝트를 시작할 때 "내가 모르는 영역이 어디지?"부터 파악하게 된다. AI를 끄고 나서도 이 습관은 남는다.

아까 인스타 마케팅 사례를 다시 보자. 나는 마케팅을 전혀 몰랐다. 근데 AI한테 "내가 뭘 알아야 해?"를 물어보고, 체크리스트를 받고, 하나씩 결정해나가는 과정에서 마케팅의 기본 구조를 이해하게 됐다. AI가 써준 게시물 3개를 얻은 게 아니다. 마케팅이 어떻게 돌아가는지를 알게 된 거다.

"사업계획서 써줘"로 끝낸 사람은 사업계획서 하나를 얻는다.
티키타카를 한 사람은 그 분야의 시장 구조, 경쟁 상황, 현실적인 실행 방법까지 머릿속에 들어온다.

"XX해줘"로 끝내는 사람은 AI가 없으면 아무것도 못 한다. 티키타카를 하는 사람은 AI 없이도 예전보다 더 잘한다. AI가 대신 해줘서 편해지는 게 아니라, AI랑 대화하는 과정 자체가 사고 훈련이 되는 거다.

이 글에서 하고 싶은 말의 핵심이 이거다. 프롬프트 잘 쓰는 법이 아니다. 생각하는 방식이 바뀌면, AI 결과물도 좋아지고, 나도 성장한다. 순서가 이거다.

AI는 신이 아니다

엄청나게 똑똑한 신입사원이다.

지식은 어마어마한데 우리 사정은 모른다. 일처리는 빠르다. 아는 것도 많다. 근데 맥락을 모른다. 어제 일어난 일을 모를 수도 있다. 자기가 모르는 것도 자신 있게 말한다.

OpenClaw 사건도 마찬가지다. "정리해줘"는 이해했는데 "지우지 마"는 놓쳤다. 신입사원이 할 법한 실수다.

이 신입사원한테 "알아서 해"라고 하면 안 된다.

배경을 설명해주고, 뭘 해야 하는지 같이 정리하고, 중간중간 확인하고, 최종 판단은 내가 한다.

이러면 세상에서 가장 유능한 파트너가 된다.

안 이러면 폐업한 고깃집을 예약하게 된다.

오늘부터 하면 되는 세 가지

하나. AI한테 뭔가 시키기 전에 "나는 이 주제에 대해 뭘 모르지?" 생각해본다. 모르는 게 있으면 답을 구하기 전에 "내가 뭘 알아야 하는지"를 먼저 물어본다.

둘. "AI가 이걸 정확히 알까?" 생각해본다. 실시간 정보, 우리만의 맥락, 최신 변화. 이런 건 틀릴 수 있다. 내가 확인한다.

셋. 큰 작업은 쪼갠다. "다 해줘"가 아니라 단계별로 나눠서 중간중간 확인하면서 간다.

세 가지다. 대단한 거 아니다.

근데 이거 하는 사람과 안 하는 사람의 차이는 꽤 크다.

AI 시대에 가장 중요한 스킬은 코딩도 아니고 프롬프트 기술도 아니다.
내가 뭘 모르는지 아는 능력이다.

📌 다음 편 예고

이번 편은 AI와 대화를 잘 하는 법이었다.

근데 AI가 채팅창 안에만 있을 필요는 없다. 요즘은 AI가 내 캘린더를 보고, 내 문서를 읽고, 내가 쓰는 도구들이랑 직접 연결돼서 일하는 세계가 열리고 있다. OpenClaw가 그래서 그렇게 화제가 된 거다.

다음 편 — AI를 채팅창 밖으로 꺼내는 법.

시리즈 팔로우하기

Claude Code Hooks: Why Your AI Forgets Everything (5-Min Fix)

@kiwibreaksme — Fri, 23 Jan 2026 10:38:52 +0000

Every single session. The same conversation.

"Use TypeScript strict mode."
"Add JSDoc comments to functions."
"Don't touch the .env file."
"Ask me before making API calls."

I was spending the first 5 minutes of every Claude Code session just... repeating myself.

Sound familiar?

The Problem Nobody Talks About

AI coding assistants are incredibly powerful. But they have one fatal flaw:

They forget everything when the session ends.

Your carefully explained coding standards? Gone.
The architectural decisions you discussed for an hour? Vanished.
That one rule about never auto-committing? It doesn't exist anymore.

I tried CLAUDE.md files. They help, but Claude doesn't always read them first. I tried system prompts. Too clunky.

Then I discovered something that changed everything.

The Feature Hiding in Plain Sight

Claude Code Hooks.

Hooks are shell commands that run automatically at specific moments in Claude's lifecycle. Not suggestions. Not guidelines Claude might follow. Actual code that executes every single time.

Think of it like this

CLAUDE.md = "Hey Claude, please remember these rules" (polite request)
Hooks = "These rules WILL run, no exceptions" (enforced automation)

The difference? One relies on AI cooperation. The other just... works.

How Hooks Work (Simple Explanation)

Hooks trigger at specific events:

Event	When It Fires	Use Case
`SessionStart`	Session begins	Load your coding rules
`PreToolUse`	Before any tool runs	Block dangerous commands
`PostToolUse`	After any tool runs	Auto-format code
`PreCompact`	Before context compression	Preserve important context
`Notification`	When Claude needs attention	Desktop alerts

You configure them in .claude/settings.json:

{
  "hooks": {
    "SessionStart": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "echo 'Your rules here'"
          }
        ]
      }
    ]
  }
}

That's it. Every session, your rules load automatically.

5 Practical Hooks You Can Use Today

1️⃣ Never Forget Your Coding Standards

{
  "hooks": {
    "SessionStart": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "echo '[RULES] 1) TypeScript strict mode 2) Add JSDoc to all functions 3) No console.log in production code'"
          }
        ]
      }
    ]
  }
}

Every session starts with your rules. No more repeating yourself.

2️⃣ Protect Sensitive Files

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "if echo \"$CLAUDE_TOOL_INPUT\" | grep -qE '(\\.env|credentials|secrets)'; then echo 'BLOCKED: Cannot edit sensitive files' >&2; exit 2; fi"
          }
        ]
      }
    ]
  }
}

Claude literally cannot edit your .env files. Not "won't"—can't.

3️⃣ Auto-Format After Every Edit

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "file=$(echo \"$CLAUDE_TOOL_INPUT\" | jq -r '.file_path'); if [[ \"$file\" == *.ts ]]; then npx prettier --write \"$file\"; fi"
          }
        ]
      }
    ]
  }
}

Every TypeScript file gets formatted automatically. No more "can you run prettier?"

4️⃣ Get Desktop Notifications

{
  "hooks": {
    "Notification": [
      {
        "matcher": ".",
        "hooks": [
          {
            "type": "command",
            "command": "osascript -e 'display notification \"Claude needs your attention\" with title \"Claude Code\"'"
          }
        ]
      }
    ]
  }
}

Walk away from your desk. Get pinged when Claude needs you.

💡 Use notify-send on Linux

5️⃣ Remember Rules After Context Compression

This one's important. When your conversation gets too long, Claude compresses the context—and often forgets your rules.

{
  "hooks": {
    "PreCompact": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "echo '[REMINDER] After compaction: TypeScript strict, JSDoc required, ask before API calls'"
          }
        ]
      }
    ]
  }
}

Your rules survive the compression. Every time.

The Setup (Literally 2 Minutes)

Step 1: Create the settings file

mkdir -p .claude
touch .claude/settings.json

Step 2: Add your hooks

{
  "hooks": {
    "SessionStart": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "echo '[My Coding Rules] 1) Your rule here 2) Another rule'"
          }
        ]
      }
    ]
  }
}

Step 3: Commit it to your repo

git add .claude/settings.json
git commit -m "Add Claude Code hooks"

✅ Done. Every developer on your team now has the same rules.

But Wait—There's Still a Problem

Hooks solve the "rules" problem beautifully. But there's something they can't do:

They can't remember WHY you built things a certain way.

Imagine this scenario

Monday: You and Claude decide to use JWT instead of sessions. Good reasons discussed.
Wednesday: New session. Claude suggests using sessions.
You: "We already decided on JWT!"
Claude: "Oh, I didn't know that."

Hooks can remind Claude of rules. But they can't preserve the reasoning behind your architectural decisions.

The Missing Piece: Context in Code

This is why I built CodeSyncer.

CodeSyncer

Claude forgets everything when the session ends. CodeSyncer makes it remember.

한국어 | English

The Problem → The Solution

Problem	Without CodeSyncer	With CodeSyncer
Context loss	Every session = start from scratch	`@codesyncer-*` tags = permanent memory
Forgot to tag	Changes go untracked	`codesyncer watch` catches everything
Rules forgotten	AI forgets guidelines mid-session	Hooks auto-remind at optimal moments
Dangerous inference	AI guesses prices, security, APIs	Auto-pause on critical keywords

Demo

Quick Start

# 1. Install
npm install -g codesyncer

# 2. Initialize
cd /path/to/your/project
codesyncer init

# 3. Let AI set up (say this to Claude)
"Read .claude/SETUP_GUIDE.md and follow the instructions"

# 4. Start coding (say this each session)
"Read CLAUDE.md"

Upgrade

npm install -g codesyncer@latest

Core Features

🏷️ Tag System

Put context IN your code. AI reads code, so it recovers context automatically.

// @codesyncer-decision: [2024-01-15] Using JWT (session management is simpler)

…

View on GitHub

⭐ Star CodeSyncer on GitHub

The idea is simple: store context directly in your code comments.

/**
 * Authentication service
 *
 * @codesyncer-decision [2026-01-15] JWT over sessions (stateless, easier scaling)
 * @codesyncer-inference Token expiry 24h (standard for web apps)
 */
export class AuthService {
  // @codesyncer-rule Never log tokens, even in debug mode
  async login(credentials: Credentials) {
    // ...
  }
}

Next session, Claude reads the code and instantly knows:

✅ What was decided
✅ Why it was decided
✅ What rules apply

No repetition. No forgetting. The context lives in the code itself.

Hooks + CodeSyncer = Complete Solution

Problem	Solution
AI forgets coding rules	Hooks → Auto-load every session
AI forgets decisions	@codesyncer-decision → Lives in code
AI makes assumptions	@codesyncer-inference → Documents reasoning
AI touches sensitive logic	@codesyncer-rule → Explicit warnings

CodeSyncer even sets up the hooks for you:

npx codesyncer init

This creates:

✅ .claude/settings.json with SessionStart and PreCompact hooks
✅ .claude/CLAUDE.md with your coding rules
✅ Tag system ready to use

Quick Start

🚀 Try CodeSyncer Now

Option 1: Just Hooks (Manual)

mkdir -p .claude
echo '{"hooks":{"SessionStart":[{"hooks":[{"type":"command","command":"echo [RULES] Your rules here"}]}]}}' > .claude/settings.json

Option 2: Full Setup (Recommended)

npx codesyncer init

TL;DR

Hook	Purpose
`SessionStart`	Load rules every session
`PreCompact`	Preserve rules after compression
`PreToolUse`	Block dangerous operations
`PostToolUse`	Auto-format, auto-lint
`Notification`	Desktop alerts

Hooks handle the "rules."
CodeSyncer handles the "reasoning."

Together, your AI finally stops forgetting.

Links

🔗 Claude Code Hooks Documentation
🔗 CodeSyncer GitHub

Have you tried hooks yet? What rules are you automating?

👇 Drop a comment below!

VibeCoding시대. 코딩면접 이제 바뀌어야한다.

@kiwibreaksme — Fri, 23 Jan 2026 05:44:41 +0000

흥미로운 연구 결과가 있습니다.

2025년 7월, AI 안전 연구 기관 METR에서 발표한 연구입니다.

특정 조건에서, 숙련된 개발자가 AI 코딩 도구를 쓰면 오히려 19% 느려졌다.

더 흥미로운 건?

개발자들은 자신이 더 빨라졌다고 착각했습니다.

하지만 이 결과를 그대로 받아들이기 전에, 맥락을 알아야 합니다.

METR 연구: 무엇을 측정했나

연구 설계

항목	내용
대상	16명의 오픈소스 개발자
코드베이스	평균 22K+ 스타, 100만+ 줄 (라이브러리/컴파일러 위주)
경험	해당 레포에 평균 5년, 1500+ 커밋
작업	실제 이슈 246개 (버그 수정, 기능, 리팩토링)
도구	Cursor Pro + Claude 3.5/3.7 Sonnet

결과

항목	수치
실제 결과	AI 사용 시 19% 느려짐
개발자 사전 예측	"24% 빨라질 것"
개발자 사후 체감	"20% 빨라진 것 같음"

⚠️ 중요한 맥락

이 연구에는 특수한 조건이 있었습니다:

극소수 샘플: 단 16명
고품질 코드베이스: Haskell 컴파일러 등 품질 기준이 극도로 높은 프로젝트
이미 극도로 익숙한 환경: 5년간 기여한 자기 프로젝트
도구 숙련도 부족: 56%만 Cursor 사용 경험 있음

연구진도 인정합니다:

"이 결과가 모든 개발자를 느리게 한다는 의미가 아님"
"몇 달 후면 다른 결과가 나올 수 있음"

다른 연구들은 뭐라고 할까?

METR만 보면 안 됩니다. 다른 연구들도 있습니다.

생산성 향상을 보여준 연구들

연구	결과
MIT/Princeton/UPenn	AI로 26% 더 많은 작업 완료
GitHub Copilot 연구	55.8% 더 빠름
IBM 연구	주니어 개발자 21-40% 생산성 향상

단, 이 연구들은 더 단순하고 고립된 작업에서 진행됐습니다.

진짜 인사이트: 상황에 따라 다르다

Sean Goedecke의 분석이 핵심을 짚습니다:

"AI의 진짜 가치는 개발자가 comfort zone 밖의 작업을 할 때 나타난다."

5년간 1500커밋 한 자기 프로젝트에서 AI 도움이 얼마나 필요할까요?
반면, 처음 보는 코드베이스나 새로운 기술을 다룰 때는?

주니어 vs 시니어: 역설적 결과

생산성 향상은 주니어가 더 큼

경력	AI로 인한 생산성 변화
주니어 (0-2년)	+21% ~ +40%
시니어 (10년+)	+7% ~ +16%

IT Revolution

하지만 프로덕션 배포는 시니어가 더 많이

Fastly의 2025년 조사:

시니어 개발자가 AI 생성 코드를 프로덕션에 2.5배 더 많이 배포한다.

시니어 (10년+): 33%가 "절반 이상이 AI 코드"
주니어 (0-2년): 13%만 "절반 이상이 AI 코드"

왜?

"수십 년간의 패턴 인식. 좋은 코드가 어떻게 생겼는지, 뭘 요청해야 하는지, AI가 언제 틀리는지 안다."

핵심 인사이트: 다른 능력이 필요하다

여러 연구를 종합하면 한 가지가 명확해집니다:

기존 "코딩 잘함"과 "바이브코딩 생산성"은 다른 능력이다.

기존 "코딩 잘함"의 정의

🧮 알고리즘 문제 해결 능력
📐 자료구조 이해
⚡ 시간/공간 복잡도 최적화
🔢 수학적 사고력
💻 언어/프레임워크 숙련도

LeetCode 잘 푸는 사람 = 코딩 잘하는 사람.

이 공식이 바이브코딩에선 통하지 않습니다.

바이브코딩 시대의 새로운 능력

1. 메타인지 (Metacognition)

"AI가 지금 뭘 모르고 있는지 아는 능력"

METR 연구에서 개발자들이 착각한 이유:

AI 출력을 과신하거나
AI 출력을 과소평가하거나

바이브코딩 잘하는 사람:

AI의 한계를 정확히 파악
어디서 AI가 틀릴지 예측
언제 직접 코딩이 더 빠른지 판단

2. 문맥 파악 (Context Awareness)

시니어가 AI 코드를 더 많이 배포하는 이유:

"좋은 코드가 어떻게 생겼는지, 뭘 요청해야 하는지, AI가 언제 틀리는지 안다."

이건 알고리즘 실력이 아닙니다.

문맥을 읽는 능력:

이 프로젝트에서 이 코드가 적절한가?
팀의 컨벤션과 맞는가?
비즈니스 요구사항을 충족하는가?

3. AI 대화 스킬 (Prompt Craft)

Frontiers in Education 연구는 프롬프트 엔지니어링을 "21세기 핵심 역량"으로 정의합니다.

필요한 능력:

비판적 사고: AI 출력 검증
창의적 표현: 의도를 명확하게 전달
언어적 감각: 모호함 없는 지시

LeetCode는 이걸 테스트하지 않습니다.

4. 커뮤니케이션

92%의 채용 담당자가 말합니다:

"소프트 스킬이 기술 스킬만큼 중요하다."

200만 개 기술직 채용 공고 분석 결과:

1위 요구 스킬: 커뮤니케이션

AI가 코딩을 대신할수록, 인간만의 협업 능력이 차별화 요소가 됩니다.

5. 적응력과 학습 능력

AI 도구는 빠르게 변합니다. METR 연구진도 말했듯이:

"몇 달 후면 다른 결과가 나올 수 있음"

2025년 초 Claude 3.5와 2026년 모델은 다릅니다.
새로운 도구에 빠르게 적응하는 능력이 중요해집니다.

경고: 40%는 이해 못 한 코드를 배포한다

Vibe Coding Statistics:

주니어 개발자의 40% 이상이 완전히 이해하지 못한 AI 생성 코드를 배포한다.

이게 왜 문제인가?

🔴 기술 부채 누적
🔴 보안 취약점 (AI 코드의 45%에 보안 결함)
🔴 디버깅 불가능

메타인지 없이 바이브코딩 = 폭탄 돌리기

새로운 역량 체크리스트

바이브코딩 시대에 필요한 능력:

역량	설명	LeetCode로 측정?
메타인지	AI의 한계 파악	❌
문맥 파악	프로젝트/팀/비즈니스 이해	❌
AI 대화 스킬	명확한 의도 전달	❌
커뮤니케이션	협업 및 설명 능력	❌
적응력	새 도구/기술 학습	❌
비판적 사고	AI 출력 검증	❌

기존 코딩 테스트는 이걸 측정하지 못합니다.

결론: 새로운 시대, 새로운 역량

여러 연구를 종합하면:

AI 코딩 도구의 효과는 상황에 따라 다르다
- 익숙한 코드베이스 vs 새로운 환경
- 단순한 작업 vs 복잡한 작업
- 도구 숙련도
기존 코딩 실력 ≠ 바이브코딩 생산성
- 알고리즘 실력만으로는 부족
- 메타인지, 문맥 파악, 커뮤니케이션이 중요
시니어의 강점은 "경험에서 오는 감각"
- AI가 언제 틀리는지 아는 것
- 좋은 코드가 어떻게 생겼는지 아는 것

바이브코딩 시대의 진짜 실력:

🧠 AI가 뭘 모르는지 아는 것
🎯 AI에게 뭘 시켜야 하는지 아는 것
✅ AI가 틀렸을 때 알아차리는 것

메타인지, 문맥 파악, 커뮤니케이션.

이게 새로운 시대의 코딩 실력입니다.

References

여러분은 어떻게 생각하시나요?

👇 댓글로 의견 공유해주세요!

skills.sh: The Skill Marketplace for AI Coding Agents You're Missing Out On

@kiwibreaksme — Fri, 23 Jan 2026 05:28:12 +0000

Ever had these thoughts while using AI coding agents?

"I'm tired of explaining React best practices every time..."
"I wish I could save my Tailwind rules somewhere..."
"How do other people set up their AI?"

It's already been done for you.

What is skills.sh?

🔗 Visit skills.sh

The Open Agent Skills Ecosystem

A marketplace for injecting expert knowledge into AI agents (Claude Code, Cursor, Copilot, etc.).

In simple terms:

🧠 Install other people's best practices into your AI
⚡ 1 minute install, no complex setup
🔓 Open source, free

Supported AI Agents

Agent	Support
Claude Code	✅
Cursor	✅
GitHub Copilot	✅
Gemini	✅
OpenAI Codex	✅
+15 more	✅

Works with almost every AI coding tool out there.

Top 10 Most Popular Skills

Rank	Skill	Installs	Purpose
1️⃣	vercel-react-best-practices	32.6K	React best practices
2️⃣	web-design-guidelines	24.7K	Web design guide
3️⃣	remotion-best-practices	12.7K	Video editing (Remotion)
4️⃣	frontend-design	4.0K	Frontend design
5️⃣	skill-creator	2.6K	Skill for creating skills
6️⃣	vue-best-practices	2.1K	Vue.js
7️⃣	three-js-best-practices	1.8K	Three.js 3D
8️⃣	supabase-best-practices	1.5K	Supabase
9️⃣	marketing-guidelines	1.2K	Marketing
🔟	tailwind-best-practices	1.0K	Tailwind CSS

30,000+ developers using React are already on this.

How to Install

Method 1: CLI (Recommended)

npx skills add vercel-labs/vercel-react-best-practices

One line. That's it.

Method 2: Inside Claude Code

/skills install vercel-labs/vercel-react-best-practices

Verify Installation

/skills

How Does It Actually Work?

Before (Without Skills)

Me: Create a React component

Claude: (generates basic code)

After (With Skills Installed)

Me: Create a React component

Claude: (applies Vercel's best practices)
- Functional component
- TypeScript type definitions
- Proper hook usage
- Performance optimization
- Accessibility considerations

Same question, different quality.

Recommended Skill Combos

🎨 Frontend Developer

npx skills add vercel-labs/vercel-react-best-practices
npx skills add vercel-labs/web-design-guidelines
npx skills add vercel-labs/frontend-design

⚡ Next.js + Supabase

npx skills add vercel-labs/vercel-react-best-practices
npx skills add supabase/supabase-best-practices

🎬 Video Editing (Remotion)

npx skills add remotion-dev/remotion-best-practices

🎯 Vue.js Developer

npx skills add vuejs/vue-best-practices

🌐 Full Stack

npx skills add vercel-labs/vercel-react-best-practices
npx skills add supabase/supabase-best-practices
npx skills add vercel-labs/web-design-guidelines

Skill Structure (For the Curious)

A skill is essentially one SKILL.md file.

my-skill/
├── SKILL.md           # Core (required)
├── reference.md       # Detailed docs (optional)
├── examples.md        # Examples (optional)
└── scripts/           # Scripts (optional)

SKILL.md Example

---
name: react-best-practices
description: React best practices. Auto-applied when writing components.
---

## Component Rules

1. Use functional components
2. Define props with TypeScript interfaces
3. useReducer over useState (complex state)
4. Always specify useEffect dependencies
5. Memoize only when necessary

## Don'ts

- Class components
- any type
- Inline styles (use Tailwind)

The AI reads this file and follows the rules.

Create Your Own Skill

Using others' skills is great, but you can also create project-specific skills.

Step 1: Create Folder

mkdir -p .claude/skills/my-rules

Step 2: Write SKILL.md

---
name: my-rules
description: Our team's coding rules
---

## Required

1. Variables in camelCase
2. Functions under 20 lines
3. Comments explain "why"
4. Error handling required

## Forbidden

- console.log (production)
- any type
- Magic numbers

Step 3: Done

Now it auto-applies when you code.

skills.sh vs Manual Prompts

Aspect	Manual Prompts	skills.sh
Type every time	Required	❌ Not needed
Consistency	🔴 Low	🟢 High
Sharing	Difficult	✅ Easy
Verified	❌	✅ Community verified
Setup time	-	1 minute

FAQ

Is it free?
Yes, it's open source and free.

Which AIs does it work with?
Claude Code, Cursor, Copilot, Gemini, and 20+ more.

Do skills conflict with each other?
Usually not. Each skill is designed to focus on a specific domain.

Can I share my own skills?
Yes, push to GitHub and register on skills.sh.

Summary

Action	Command
Install skill	`npx skills add owner/repo`
List installed	`/skills`
Call directly	`/skill-name`
Create your own	`.claude/skills/name/SKILL.md`

Get Started

Takes 1 minute.

# Install the most popular React skill
npx skills add vercel-labs/vercel-react-best-practices

Now when you write React code, Vercel's best practices are automatically applied.

Links

🔗 skills.sh - Skill Marketplace
🔗 skills.sh Docs
🔗 Claude Code Skills Official Docs

What skills are you using?

AI 코딩 에이전트용 스킬 마켓플레이스 (몰랐으면 손해)

@kiwibreaksme — Fri, 23 Jan 2026 05:24:58 +0000

AI 코딩 에이전트 쓰면서 이런 생각 해본 적 있음?

"React 베스트 프랙티스 매번 설명하기 귀찮은데..."
"Tailwind 쓰는 규칙 어디 저장해두고 싶다..."
"다른 사람들은 어떻게 설정해서 쓰지?"

이미 다 만들어져 있습니다.

skills.sh가 뭔데?

🔗 skills.sh 바로가기

The Open Agent Skills Ecosystem

AI 에이전트(Claude Code, Cursor, Copilot 등)에 전문 지식을 주입하는 스킬 마켓플레이스입니다.

쉽게 말해:

🧠 남들이 만든 베스트 프랙티스를 내 AI에 장착
⚡ 설치 1분, 복잡한 설정 없음
🔓 오픈소스, 무료

지원하는 AI 에이전트

에이전트	지원
Claude Code	✅
Cursor	✅
GitHub Copilot	✅
Gemini	✅
OpenAI Codex	✅
+15개 이상	✅

거의 모든 AI 코딩 도구에서 작동합니다.

순위	스킬	설치 수	용도
1️⃣	vercel-react-best-practices	32.6K	React 베스트 프랙티스
2️⃣	web-design-guidelines	24.7K	웹 디자인 가이드
3️⃣	remotion-best-practices	12.7K	영상 편집 (Remotion)
4️⃣	frontend-design	4.0K	프론트엔드 디자인
5️⃣	skill-creator	2.6K	스킬 만드는 스킬
6️⃣	vue-best-practices	2.1K	Vue.js
7️⃣	three-js-best-practices	1.8K	Three.js 3D
8️⃣	supabase-best-practices	1.5K	Supabase
9️⃣	marketing-guidelines	1.2K	마케팅
🔟	tailwind-best-practices	1.0K	Tailwind CSS

설치 방법

방법 1: CLI (추천)

npx skills add vercel-labs/vercel-react-best-practices

한 줄이면 끝.

방법 2: Claude Code 내에서

/skills install vercel-labs/vercel-react-best-practices

설치 확인

/skills

실제로 어떻게 작동하나?

Before (스킬 없이)

나: React 컴포넌트 만들어줘

Claude: (그냥 기본적인 코드 생성)

After (스킬 설치 후)

나: React 컴포넌트 만들어줘

Claude: (Vercel의 베스트 프랙티스 적용)
- 함수형 컴포넌트
- TypeScript 타입 정의
- 적절한 훅 사용
- 성능 최적화 고려
- 접근성 고려

같은 질문, 다른 품질.

스킬 구조 (궁금한 사람만)

스킬은 결국 SKILL.md 파일 하나입니다.

my-skill/
├── SKILL.md           # 핵심 (필수)
├── reference.md       # 상세 문서 (선택)
├── examples.md        # 예제 (선택)
└── scripts/           # 스크립트 (선택)

SKILL.md 예시

---
name: react-best-practices
description: React 베스트 프랙티스. 컴포넌트 작성 시 자동 적용.
---

## 컴포넌트 작성 규칙

1. 함수형 컴포넌트 사용
2. Props는 TypeScript 인터페이스로 정의
3. useState보다 useReducer (복잡한 상태)
4. useEffect 의존성 배열 명시
5. 메모이제이션은 필요할 때만

## 금지 사항

- class 컴포넌트
- any 타입
- 인라인 스타일 (Tailwind 사용)

AI가 이 파일을 읽고 규칙을 따릅니다.

내 스킬 만들기

남의 거 쓰는 것도 좋지만, 내 프로젝트 전용 스킬도 만들 수 있음.

Step 1: 폴더 생성

mkdir -p .claude/skills/my-rules

Step 2: SKILL.md 작성

---
name: my-rules
description: 우리 팀 코딩 규칙
---

## 필수 규칙

1. 변수명은 camelCase
2. 함수는 20줄 이하
3. 주석은 "왜"를 설명
4. 에러 핸들링 필수

## 금지

- console.log (프로덕션)
- any 타입
- 매직 넘버

Step 3: 끝

이제 코드 짤 때 자동으로 적용됨.

skills.sh vs 직접 프롬프트

항목	직접 프롬프트	skills.sh
매번 입력	필요	❌ 불필요
일관성	🔴 낮음	🟢 높음
공유	어려움	✅ 쉬움
검증됨	❌	✅ 커뮤니티 검증
설치	-	1분

자주 묻는 질문

무료인가요?
네, 오픈소스 기반이라 무료입니다.

어떤 AI에서 작동하나요?
Claude Code, Cursor, Copilot, Gemini 등 20개 이상 지원합니다.

스킬끼리 충돌하나요?
보통 안 합니다. 각 스킬은 특정 도메인에 집중하도록 설계되어 있습니다.

내가 만든 스킬 공유할 수 있나요?
네, GitHub에 올리고 skills.sh에 등록하면 됩니다.

요약

할 일	명령어
스킬 설치	`npx skills add owner/repo`
설치 목록 확인	`/skills`
스킬 직접 호출	`/skill-name`
내 스킬 만들기	`.claude/skills/name/SKILL.md`

시작하기

1분이면 됩니다.

# 가장 인기 있는 React 스킬 설치
npx skills add vercel-labs/vercel-react-best-practices

이제 React 코드 짜면 자동으로 Vercel 베스트 프랙티스가 적용됩니다.

링크

🔗 skills.sh - 스킬 마켓플레이스
🔗 skills.sh 문서
🔗 Claude Code Skills 공식 문서

어떤 스킬 쓰고 계신가요?

👇 댓글로 추천해주세요!

Claude Code Hooks 완벽 가이드: AI가 맨날 까먹는 이유와 해결법

@kiwibreaksme — Fri, 23 Jan 2026 04:43:20 +0000

매번. 똑같은. 대화.

"TypeScript strict mode 써."
"함수마다 JSDoc 주석 달아."
".env 파일은 건드리지 마."
"API 호출 전에 나한테 물어봐."

저는 Claude Code 세션 시작할 때마다 첫 5분을 이런 얘기 반복하는 데 쓰고 있었습니다.

혹시 공감되시나요?

아무도 말 안 하는 문제

AI 코딩 어시스턴트는 정말 강력합니다. 근데 치명적인 약점이 하나 있어요.

세션 끝나면 다 잊어버림.

어제 1시간 동안 설명한 코딩 규칙? 사라짐.
그제 논의한 아키텍처 결정? 없던 일.
"절대 자동 커밋하지 마"라고 했던 거? 기억 못함.

CLAUDE.md 파일도 써봤습니다. 도움은 되는데, Claude가 항상 먼저 읽지는 않더라고요. 시스템 프롬프트도 써봤는데 너무 번거롭고.

그러다가 모든 걸 바꾼 기능을 발견했습니다.

숨겨진 기능: Claude Code Hooks

Hooks는 Claude의 라이프사이클 특정 시점에 자동으로 실행되는 셸 명령어입니다. 제안이 아니에요. Claude가 따를 수도 있는 가이드라인이 아닙니다. 매번 무조건 실행되는 실제 코드입니다.

이렇게 생각하면 쉬워요

CLAUDE.md = "Claude야, 이 규칙들 기억해줘" (정중한 부탁)
Hooks = "이 규칙은 무조건 실행됨" (강제 자동화)

차이점? 하나는 AI의 협조에 의존하고, 다른 하나는 그냥... 작동합니다.

Hooks 작동 원리 (쉬운 설명)

Hooks는 특정 이벤트에서 발동됩니다:

이벤트	발동 시점	활용 예시
`SessionStart`	세션 시작	코딩 규칙 로드
`PreToolUse`	도구 실행 전	위험한 명령 차단
`PostToolUse`	도구 실행 후	코드 자동 포맷팅
`PreCompact`	컨텍스트 압축 전	중요 컨텍스트 보존
`Notification`	알림 필요 시	데스크톱 알림

설정은 .claude/settings.json에서 합니다:

{
  "hooks": {
    "SessionStart": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "echo '여기에 규칙 작성'"
          }
        ]
      }
    ]
  }
}

끝입니다. 매 세션마다 규칙이 자동으로 로드됩니다.

지금 바로 쓸 수 있는 실용적인 Hooks 5가지

1️⃣ 코딩 규칙 자동 로드

{
  "hooks": {
    "SessionStart": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "echo '[규칙] 1) TypeScript strict mode 2) 모든 함수에 JSDoc 3) 프로덕션에 console.log 금지'"
          }
        ]
      }
    ]
  }
}

매 세션이 규칙과 함께 시작됩니다. 더 이상 반복할 필요 없음.

2️⃣ 민감한 파일 보호

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "if echo \"$CLAUDE_TOOL_INPUT\" | grep -qE '(\\.env|credentials|secrets)'; then echo '차단됨: 민감한 파일 수정 불가' >&2; exit 2; fi"
          }
        ]
      }
    ]
  }
}

Claude가 .env 파일을 수정 못 합니다. "안 하는" 게 아니라 "못 하는" 겁니다.

3️⃣ 수정 후 자동 포맷팅

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "file=$(echo \"$CLAUDE_TOOL_INPUT\" | jq -r '.file_path'); if [[ \"$file\" == *.ts ]]; then npx prettier --write \"$file\"; fi"
          }
        ]
      }
    ]
  }
}

TypeScript 파일이 자동으로 포맷팅됩니다. "prettier 돌려줘" 안 해도 됨.

4️⃣ 데스크톱 알림 받기

{
  "hooks": {
    "Notification": [
      {
        "matcher": ".",
        "hooks": [
          {
            "type": "command",
            "command": "osascript -e 'display notification \"Claude가 응답을 기다리고 있습니다\" with title \"Claude Code\"'"
          }
        ]
      }
    ]
  }
}

자리 비워도 됩니다. Claude가 필요할 때 알림이 옵니다.

💡 Linux는 notify-send 사용

5️⃣ 컨텍스트 압축 후에도 규칙 유지

이거 중요합니다. 대화가 길어지면 Claude가 컨텍스트를 압축하는데, 이때 규칙을 종종 까먹습니다.

{
  "hooks": {
    "PreCompact": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "echo '[리마인더] 압축 후에도 기억할 것: TypeScript strict, JSDoc 필수, API 호출 전 확인'"
          }
        ]
      }
    ]
  }
}

압축 후에도 규칙이 살아남습니다. 매번.

설정 방법 (진짜 2분)

Step 1: 설정 파일 생성

mkdir -p .claude
touch .claude/settings.json

Step 2: Hooks 추가

{
  "hooks": {
    "SessionStart": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "echo '[내 코딩 규칙] 1) 규칙1 2) 규칙2'"
          }
        ]
      }
    ]
  }
}

Step 3: 레포에 커밋

git add .claude/settings.json
git commit -m "Add Claude Code hooks"

✅ 끝. 이제 팀원 모두가 같은 규칙을 공유합니다.

근데 아직 문제가 하나 남음

Hooks는 "규칙" 문제를 아름답게 해결합니다. 하지만 못하는 게 있어요:

왜 그렇게 만들었는지는 기억 못함.

이런 상황 상상해보세요

월요일: Claude랑 JWT를 쓰기로 결정. 충분한 논의 끝에.
수요일: 새 세션. Claude가 세션 방식을 제안함.
나: "우리 JWT 쓰기로 했잖아!"
Claude: "아, 몰랐어요."

Hooks는 규칙을 상기시킬 수 있습니다. 하지만 아키텍처 결정의 이유는 보존하지 못해요.

빠진 퍼즐 조각: 코드 안의 컨텍스트

그래서 CodeSyncer를 만들었습니다.

CodeSyncer

Claude forgets everything when the session ends. CodeSyncer makes it remember.

한국어 | English

The Problem → The Solution

Problem	Without CodeSyncer	With CodeSyncer
Context loss	Every session = start from scratch	`@codesyncer-*` tags = permanent memory
Forgot to tag	Changes go untracked	`codesyncer watch` catches everything
Rules forgotten	AI forgets guidelines mid-session	Hooks auto-remind at optimal moments
Dangerous inference	AI guesses prices, security, APIs	Auto-pause on critical keywords

Demo

Quick Start

# 1. Install
npm install -g codesyncer

# 2. Initialize
cd /path/to/your/project
codesyncer init

# 3. Let AI set up (say this to Claude)
"Read .claude/SETUP_GUIDE.md and follow the instructions"

# 4. Start coding (say this each session)
"Read CLAUDE.md"

Upgrade

npm install -g codesyncer@latest

Core Features

🏷️ Tag System

Put context IN your code. AI reads code, so it recovers context automatically.

// @codesyncer-decision: [2024-01-15] Using JWT (session management is simpler)

…

View on GitHub

아이디어는 간단해요: 코드 주석에 컨텍스트를 직접 저장하는 겁니다.

/**
 * 인증 서비스
 *
 * @codesyncer-decision [2026-01-15] 세션 대신 JWT 선택 (stateless, 스케일링 용이)
 * @codesyncer-inference 토큰 만료 24시간 (웹앱 표준)
 */
export class AuthService {
  // @codesyncer-rule 디버그 모드에서도 토큰 로깅 금지
  async login(credentials: Credentials) {
    // ...
  }
}

다음 세션에서 Claude가 코드를 읽으면 즉시 알게 됩니다:

✅ 뭘 결정했는지
✅ 왜 그렇게 결정했는지
✅ 어떤 규칙이 적용되는지

반복 없음. 까먹음 없음. 컨텍스트가 코드 자체에 살아있습니다.

Hooks + CodeSyncer = 완벽한 조합

문제	해결책
AI가 코딩 규칙을 까먹음	Hooks → 매 세션 자동 로드
AI가 결정을 까먹음	@codesyncer-decision → 코드에 남음
AI가 추론함	@codesyncer-inference → 근거 문서화
AI가 민감한 로직 건드림	@codesyncer-rule → 명시적 경고

CodeSyncer는 Hooks도 자동으로 설정해줍니다:

npx codesyncer init

이렇게 생성됩니다:

✅ .claude/settings.json - SessionStart, PreCompact hooks 포함
✅ .claude/CLAUDE.md - 코딩 규칙
✅ 태그 시스템 바로 사용 가능

빠른 시작

🚀 CodeSyncer 시작하기

⭐ CodeSyncer GitHub에서 스타 누르기

옵션 1: Hooks만 (수동)

mkdir -p .claude
echo '{"hooks":{"SessionStart":[{"hooks":[{"type":"command","command":"echo [규칙] 여기에 규칙"}]}]}}' > .claude/settings.json

옵션 2: 전체 설정 (추천)

npx codesyncer init

요약

Hook	용도
`SessionStart`	매 세션 규칙 로드
`PreCompact`	압축 후에도 규칙 유지
`PreToolUse`	위험한 작업 차단
`PostToolUse`	자동 포맷팅, 린팅
`Notification`	데스크톱 알림

Hooks는 "규칙"을 담당합니다.
CodeSyncer는 "이유"를 담당합니다.

둘을 같이 쓰면, AI가 드디어 까먹지 않습니다.

링크

🔗 Claude Code Hooks 공식 문서
🔗 CodeSyncer GitHub

Hooks 써보셨나요? 어떤 규칙을 자동화하고 계신가요?

👇 댓글로 공유해주세요!

Claude Code Keeps Forgetting Your Project? Here's the Fix (2026)

@kiwibreaksme — Sat, 17 Jan 2026 04:58:18 +0000

The Frustration We All Know

Me: "Let's continue the payment feature from yesterday"
Claude: "I don't have context from previous sessions.
        Could you explain what you've built so far?"
Me: *sighs deeply*

If you use Claude Code, you've been here.

Three hours architecting a solution. Explaining every decision. Finally getting AI to understand your codebase.

Next day? Blank slate.

This Is a Known Problem

MIT Technology Review calls it the "Context Loss Problem":

"The biggest limitation of AI coding assistants is that LLMs can only hold a limited amount of information in their context window, and they tend to forget what they were doing in longer tasks."

Even with 200K token context windows, the fundamental issue remains:

What AI Promises	What Actually Happens
"I understand your codebase"	Forgets after session ends
"I'll follow your patterns"	Reverts to training data defaults
"I remember our decisions"	What decisions?

For solo developers on side projects, this hits harder. Teams might document things. When you're alone, context lives in your head—and dies with the session.

What I Tried (And What Failed)

❌ Longer prompts

Pasting entire codebases. Hit token limits. AI got confused.

❌ Session summaries

Manual notes at session end. Forgot to do it. Notes got stale.

❌ Hoping AI would remember

Narrator: It did not.

What Actually Works

After months of frustration, I found a two-part solution:

Part 1: CLAUDE.md (Built-in Feature)

Claude Code automatically reads CLAUDE.md in your project root. This is your persistent rulebook.

# CLAUDE.md

## Project Rules
- TypeScript strict mode, always
- API base URL: https://api.myapp.com/v2
- Auth: JWT with 24-hour expiry
- Never guess business logic—ask first

## Architecture
- /src/services → Business logic
- /src/api → Express routes
- /src/utils → Shared utilities

## Critical: Don't Assume
- Payment amounts → ASK
- API endpoints → ASK
- Security settings → ASK

This survives sessions. AI reads it first. Huge improvement.

But it's not enough. CLAUDE.md tells AI the rules—not the reasons behind your code.

Part 2: CodeSyncer (My Solution)

I built an open source tool that stores context inside your code itself.

The idea: What if every AI decision was recorded as a comment tag?

/**
 * Payment processor
 *
 * @codesyncer-decision [2026-01-15] Chose synchronous processing
 *   → User feedback showed async confused customers at checkout
 * @codesyncer-inference Minimum $1.00 (Stripe policy)
 * @codesyncer-todo Add refund logic after v1 launch
 */
async function processPayment(amount: number) {
  // @codesyncer-why Idempotency key prevents duplicate charges
  //   on network retry (learned this the hard way)
  const idempotencyKey = generateKey(userId, amount);

  // ...
}

Next session, AI reads the code and instantly knows:

What was decided
Why it was decided
What's still pending

No re-explaining. No context loss. The code is the context.

Quick Start

# Install
npm install -g codesyncer

# Initialize (creates CLAUDE.md structure)
npx codesyncer init

# Watch mode: auto-syncs tags to DECISIONS.md
npx codesyncer watch

That's it. 5 minutes to start.

CodeSyncer

Claude forgets everything when the session ends. CodeSyncer makes it remember.

한국어 | English

The Problem → The Solution

Problem	Without CodeSyncer	With CodeSyncer
Context loss	Every session = start from scratch	`@codesyncer-*` tags = permanent memory
Forgot to tag	Changes go untracked	`codesyncer watch` catches everything
Rules forgotten	AI forgets guidelines mid-session	Hooks auto-remind at optimal moments
Dangerous inference	AI guesses prices, security, APIs	Auto-pause on critical keywords

Demo

Quick Start

# 1. Install
npm install -g codesyncer

# 2. Initialize
cd /path/to/your/project
codesyncer init

# 3. Let AI set up (say this to Claude)
"Read .claude/SETUP_GUIDE.md and follow the instructions"

# 4. Start coding (say this each session)
"Read CLAUDE.md"

Upgrade

npm install -g codesyncer@latest

Core Features

🏷️ Tag System

Put context IN your code. AI reads code, so it recovers context automatically.

// @codesyncer-decision: [2024-01-15] Using JWT (session management is simpler)

…

View on GitHub

The Tag System

Tag	When to Use	Example
`@codesyncer-decision`	After discussing with AI	`Chose REST over GraphQL (team familiarity)`
`@codesyncer-inference`	AI made an assumption	`Page size 20 (standard UX practice)`
`@codesyncer-todo`	Needs follow-up	`Add rate limiting before production`
`@codesyncer-context`	Business logic explanation	`GDPR requires 30-day data retention`
`@codesyncer-why`	Non-obvious implementation	`Using any type (external lib has no types)`

These tags become searchable documentation:

# Find all pending items
grep -r "@codesyncer-todo" ./src

# Find all architectural decisions
grep -r "@codesyncer-decision" ./src

For Teams: Gas Town

Credit where it's due—Steve Yegge (Google veteran, worked on Grok) built Gas Town tackling the same problem at enterprise scale.

Gas Town

Multi-agent orchestration system for Claude Code, GitHub Copilot, and other AI agents with persistent work tracking

Overview

Gas Town is a workspace manager that lets you coordinate multiple AI coding agents (Claude Code, GitHub Copilot, Codex, Gemini, and others) working on different tasks. Instead of losing context when agents restart, Gas Town persists work state in git-backed hooks, enabling reliable multi-agent workflows.

What Problem Does This Solve?

Challenge	Gas Town Solution
Agents lose context on restart	Work persists in git-backed hooks
Manual agent coordination	Built-in mailboxes, identities, and handoffs
4-10 agents become chaotic	Scale comfortably to 20-30 agents
Work state lost in agent memory	Work state stored in Beads ledger

Architecture

<div class="js-render-enrichment-target" data-json='{"data":"graph TB\n Mayor[The Mayor AI Coordinator]\n Town[Town Workspace ~/gt/]\n\n Town --> Mayor\n Town --> Rig1[Rig: Project A]\n Town --> Rig2[Rig: Project B]\n\n Rig1 --> Crew1[Crew Member Your workspace]\n Rig1 --> Hooks1[Hooks Persistent storage]\n Rig1 --> Polecats1[Polecats Worker agents]\n\n Rig2 --> Crew2[Crew Member]\n Rig2 --> Hooks2[Hooks]\n Rig2 --> Polecats2[Polecats]\n\n Hooks1 -.git worktree.-> GitRepo1[Git Repository]\n Hooks2 -.git worktree.-> GitRepo2[Git Repository]\n\n style Mayor fill:#e1f5ff,color:#000000\n style Town fill:#f0f0f0,color:#000000\n style Rig1 fill:#fff4e1,color:#000000\n style Rig2 fill:#fff4e1,color:#000000\n"}' data-plain="graph TB
Mayor[The Mayor AI Coordinator]
Town[Town Workspace ~/gt/]
Town --> Mayor
Town --> Rig1[Rig: Project A]
Town --> Rig2[Rig: Project B]

Rig1 --&gt; Crew1[Crew Member&lt;br/&gt;Your workspace]
Rig1 --&gt; Hooks1[Hooks&lt;br/&gt;Persistent storage]
Rig1 --&gt; Polecats1[Polecats&lt;br/&gt;Worker agents]

Rig2 --&gt; Crew2[Crew Member]
Rig2 --&gt; Hooks2[Hooks]
Rig2 --&gt; Polecats2[Polecats]

Hooks1 -.git worktree.-&gt; GitRepo1[Git Repository]
Hooks2 -.git worktree.-&gt; GitRepo2[Git Repository]

style Mayor fill:#e1f5ff,color:#000000
style Town fill:#f0f0f0,color:#000000
style Rig1 fill:#fff4e1,color:#000000
style Rig2 fill:#fff4e1,color:#000000

" dir="auto">

graph TB

    Mayor[The Mayor<br/>AI Coordinator]

    Town[Town Workspace<br/>~/gt/]

    Town --> Mayor

    Town --> Rig1[Rig: Project A]

    Town --> Rig2[Rig: Project B]

    Rig1 --> Crew1[Crew Member<br/>Your workspace]

    Rig1 --> Hooks1[Hooks<br/>Persistent storage]

    Rig1 --> Polecats1[Polecats<br/>Worker agents]

Rig2 --&gt; Crew2[Crew Member]</pre>…</div>

View on GitHub

His approach: Run 20-30 AI agents simultaneously with a "Mayor" AI orchestrating them. Git-based state persistence.

Impressive, but the learning curve is steep. He says it requires "Stage 7+ AI-assisted development experience."

Quick Comparison

	Gas Town	CodeSyncer
Tagline	"Scale your agents"	"Remember your context"
Target	Teams, enterprise	Solo developers
Agents	20-30 simultaneous	1, deeply
Setup time	Hours (Go, complex concepts)	5 minutes
State storage	Git worktrees	Code comments

Same philosophy: "AI is ephemeral, but context should be permanent."

Different scale: Pick based on your needs.

Real Workflow Example

Here's how my sessions look now:

Day 1

Me: "Let's add Stripe payments"

Claude: ⚠️ Payment keyword detected. Let me confirm:
- Which payment provider?
- Supported currencies?
- Minimum amount?

Me: "Stripe, USD/EUR/KRW, minimum $1"

Claude: ✅ Recording decision...

*Creates code with:*
// @codesyncer-decision [2026-01-17] Stripe for payments
//   Supports USD, EUR, KRW. Min $1 (Stripe policy).

Day 2 (New Session)

Me: "Continue the payment feature"

Claude: *reads codebase*

"I see from the code:
- You're using Stripe (decision from Jan 17)
- Supporting USD/EUR/KRW
- Minimum $1

Should I add the webhook handler next?"

Me: 🎉

No re-explaining. No lost context. It just works.

The 2026 Bottleneck

AI models are getting smarter every month. GPT-5, Claude 4, Gemini Ultra—they'll all be incredible.

But here's my take:

The bottleneck isn't "smarter AI." It's "better context management."

The devs who master context persistence will ship faster than those waiting for AI to magically remember.

Try It Today

For solo developers:

npx codesyncer init
npx codesyncer watch

→ CodeSyncer on GitHub

For teams:
→ Gas Town on GitHub

Your Turn

Have you struggled with Claude Code forgetting context?

What workarounds have you tried?

Drop a comment below — I'd love to hear how others are solving this.

If this helped, a ⭐ on the repo means a lot. Building in public, feedback welcome!

What I Learned from Steve Yegge's Gas Town — And a Small Tool for Solo Developers

@kiwibreaksme — Fri, 16 Jan 2026 13:26:33 +0000

recently discovered the most impressive project in the AI coding ecosystem.

Steve Yegge's Gas Town.

For those who don't know Steve Yegge:

Senior engineer at Google for 10+ years
Famous developer blogger ("Stevey's Blog Rants")
Worked on Grok
Recently co-authored "Wiring the Winning Organization" with Gene Kim

Gas Town, which he released on New Year's 2026, felt less like a tool and more like a manifesto for the future of AI coding.

The Core Insight of Gas Town

"AI agents are ephemeral. But work context should be permanent."

This matters because the biggest pain point we face with AI coding assistants is context loss.

You spend 3 hours designing architecture with Claude yesterday. Open a new session today? Blank slate. MIT Technology Review calls this one of the biggest limitations of LLMs.

Steve Yegge tackled this problem head-on.

Gas Town's Approach

1. Using Git as a trusted state store

Work state can be recovered even after agent crashes or restarts.

2. "Mayor" AI orchestrates multiple agents

20-30 agents working on different tasks simultaneously.

3. "Hooks" persist work state to Git worktree

Embracing agent ephemerality while ensuring continuity.

4. "Convoy" bundles multiple issues for tracking

Visibility into progress on complex projects.

Looking at this architecture, I realized this isn't just an "AI tool" — it's a new development paradigm for the AI era.

steveyegge / gastown

Gas Town - multi-agent workspace manager

Gas Town

Multi-agent orchestration system for Claude Code, GitHub Copilot, and other AI agents with persistent work tracking

Overview

What Problem Does This Solve?

Challenge	Gas Town Solution
Agents lose context on restart	Work persists in git-backed hooks
Manual agent coordination	Built-in mailboxes, identities, and handoffs
4-10 agents become chaotic	Scale comfortably to 20-30 agents
Work state lost in agent memory	Work state stored in Beads ledger

Architecture

graph TB
    Mayor[The Mayor<br/>AI Coordinator]
    Town[Town Workspace<br/>~/gt/]
    Town --> Mayor
    Town --> Rig1[Rig: Project A]
    Town --> Rig2[Rig: Project B]
    Rig1 --> Crew1[Crew Member<br/>Your workspace]
    Rig1 --> Hooks1[Hooks<br/>Persistent storage]
    Rig1 --> Polecats1[Polecats<br/>Worker agents]

    Rig2 --> Crew2[Crew Member]

…

View on GitHub

I'm Also Building Something Similar

Gas Town is optimized for large teams and complex enterprise projects. Environments where you'd actually run 20-30 agents.

But what about solo developers like me, working on side projects?

I didn't need 20 agents. I wanted deep collaboration with one AI that remembers "where we left off yesterday" and "why we built it this way."

I'm building a tool called CodeSyncer.

Core idea:

Gas Town stores state in Git
CodeSyncer stores context in code comments themselves

/**
 * Payment processor
 *
 * @codesyncer-decision [2026-01-15] Chose sync processing (UX priority)
 * @codesyncer-inference Minimum amount $1 (PG policy)
 * @codesyncer-todo Add refund logic
 */
async function processPayment(amount: number) {
  // @codesyncer-why Idempotency key prevents duplicate charges
  const idempotencyKey = generateKey(amount);
  // ...
}

Next session, AI reads the code and instantly knows "why" it was built this way.

Start in 5 minutes, no complex setup.

npx codesyncer init
npx codesyncer watch

bitjaru / codesyncer

Claude forgets everything when the session ends. CodeSyncer makes it remember.

CodeSyncer

Claude forgets everything when the session ends. CodeSyncer makes it remember.

한국어 | English

The Problem → The Solution

Problem	Without CodeSyncer	With CodeSyncer
Context loss	Every session = start from scratch	`@codesyncer-*` tags = permanent memory
Forgot to tag	Changes go untracked	`codesyncer watch` catches everything
Rules forgotten	AI forgets guidelines mid-session	Hooks auto-remind at optimal moments
Dangerous inference	AI guesses prices, security, APIs	Auto-pause on critical keywords

Demo

Quick Start

# 1. Install
npm install -g codesyncer

# 2. Initialize
cd /path/to/your/project
codesyncer init

# 3. Let AI set up (say this to Claude)
"Read .claude/SETUP_GUIDE.md and follow the instructions"

# 4. Start coding (say this each session)
"Read CLAUDE.md"

Upgrade

npm install -g codesyncer@latest

Core Features

🏷️ Tag System

Put context IN your code. AI reads code, so it recovers context automatically.

// @codesyncer-decision: [2024-01-15] Using JWT (session management is simpler)

…

View on GitHub

Summary

	Gas Town	CodeSyncer
Slogan	Scale your agents	Remember your context
Target	Teams/Enterprise	Solo developers
Agents	20-30 simultaneous	1, deeply
State storage	Git worktree	Code comments

The philosophy is the same: "AI is ephemeral, but context should be permanent."

Just different targets and approaches.

Wrapping Up

In 2026, the real differentiator in AI coding won't be "smarter models" — it'll be "better context management".

Steve Yegge showed the way with Gas Town. I'm trying to make a small contribution for solo developers.

Both are open source. If you're interested in AI coding, check them out.

Gas Town - For teams/enterprise
CodeSyncer - For solo developers

If you've been struggling with this too, share your experience in the comments!

Steve Yegge의 Gas Town을 보고 배운 것들 — 그리고 개인 개발자를 위한 작은 도구

@kiwibreaksme — Fri, 16 Jan 2026 13:25:18 +0000

최근 AI 코딩 생태계에서 가장 인상적인 프로젝트를 발견했습니다.

Steve Yegge의 Gas Town입니다.

Steve Yegge를 모르시는 분들을 위해 간단히 소개하면:

Google에서 10년 넘게 일한 시니어 엔지니어
"Stevey's Blog Rants"로 유명한 개발자 블로거
Grok 개발에 참여
최근 Gene Kim과 함께 "Wiring the Winning Organization" 공동 저술

그가 2026년 새해에 공개한 Gas Town은 단순한 도구가 아니라, AI 코딩의 미래에 대한 하나의 선언문 같았습니다.

Gas Town의 핵심 통찰

"AI 에이전트는 일시적(ephemeral)이다. 하지만 작업 맥락은 영구적이어야 한다."

이게 왜 중요하냐면, 우리가 AI 코딩 어시스턴트를 쓰면서 겪는 가장 큰 고통이 바로 "컨텍스트 손실"이기 때문입니다.

어제 Claude랑 3시간 동안 아키텍처 설계했는데, 오늘 새 세션 열면 백지상태. MIT Technology Review도 이걸 LLM의 가장 큰 한계로 꼽습니다.

Steve Yegge는 이 문제를 정면으로 해결하려 했습니다.

Gas Town의 접근법

1. Git을 신뢰할 수 있는 상태 저장소로 활용

에이전트가 크래시해도, 재시작해도 작업 상태 복구 가능

2. "Mayor"라는 조정자 AI가 여러 에이전트를 오케스트레이션

20-30개 에이전트가 동시에 다른 작업 수행

3. "Hooks"로 작업 상태를 Git worktree에 영구 저장

에이전트의 일시성을 수용하면서도 연속성 확보

4. "Convoy"로 여러 이슈를 묶어서 추적

복잡한 프로젝트에서 진행 상황 가시화

이 아키텍처를 보면서 느낀 건, 이건 단순히 "AI 도구"가 아니라 "AI 시대의 새로운 개발 패러다임"이라는 것이었습니다.

steveyegge / gastown

Gas Town - multi-agent workspace manager

Gas Town

Multi-agent orchestration system for Claude Code, GitHub Copilot, and other AI agents with persistent work tracking

Overview

What Problem Does This Solve?

Challenge	Gas Town Solution
Agents lose context on restart	Work persists in git-backed hooks
Manual agent coordination	Built-in mailboxes, identities, and handoffs
4-10 agents become chaotic	Scale comfortably to 20-30 agents
Work state lost in agent memory	Work state stored in Beads ledger

Architecture

graph TB
    Mayor[The Mayor<br/>AI Coordinator]
    Town[Town Workspace<br/>~/gt/]
    Town --> Mayor
    Town --> Rig1[Rig: Project A]
    Town --> Rig2[Rig: Project B]
    Rig1 --> Crew1[Crew Member<br/>Your workspace]
    Rig1 --> Hooks1[Hooks<br/>Persistent storage]
    Rig1 --> Polecats1[Polecats<br/>Worker agents]

    Rig2 --> Crew2[Crew Member]

…

View on GitHub

저도 마침 비슷한 도구를 만들고 있습니다

Gas Town은 대규모 팀이나 복잡한 엔터프라이즈 프로젝트에 최적화되어 있습니다. 20-30개 에이전트를 돌릴 일이 있는 환경이죠.

하지만 저처럼 혼자 사이드 프로젝트 하는 개인 개발자는 어떨까요?

에이전트 20개가 아니라, 하나의 AI와 깊이 협업하면서 "어제 어디까지 했는지", "왜 이렇게 구현했는지"를 기억하게 하고 싶었습니다.

CodeSyncer라는 도구를 만들고 있습니다.

핵심 아이디어:

Gas Town이 Git에 상태를 저장한다면
CodeSyncer는 코드 주석 자체에 컨텍스트를 저장

/**
 * 결제 처리 함수
 *
 * @codesyncer-decision [2026-01-15] 동기 처리 선택 (UX 우선)
 * @codesyncer-inference 최소 금액 100원 (PG사 정책)
 * @codesyncer-todo 환불 로직 추가 필요
 */
async function processPayment(amount: number) {
  // @codesyncer-why 멱등성 키로 중복 결제 방지
  const idempotencyKey = generateKey(amount);
  // ...
}

다음 세션에서 AI가 코드를 읽으면 "왜 이렇게 구현했는지" 바로 파악할 수 있습니다.

5분이면 시작할 수 있고, 복잡한 설정 없이 바로 쓸 수 있습니다.

npx codesyncer init
npx codesyncer watch

bitjaru / codesyncer

Claude forgets everything when the session ends. CodeSyncer makes it remember.

CodeSyncer

Claude forgets everything when the session ends. CodeSyncer makes it remember.

한국어 | English

The Problem → The Solution

Problem	Without CodeSyncer	With CodeSyncer
Context loss	Every session = start from scratch	`@codesyncer-*` tags = permanent memory
Forgot to tag	Changes go untracked	`codesyncer watch` catches everything
Rules forgotten	AI forgets guidelines mid-session	Hooks auto-remind at optimal moments
Dangerous inference	AI guesses prices, security, APIs	Auto-pause on critical keywords

Demo

Quick Start

# 1. Install
npm install -g codesyncer

# 2. Initialize
cd /path/to/your/project
codesyncer init

# 3. Let AI set up (say this to Claude)
"Read .claude/SETUP_GUIDE.md and follow the instructions"

# 4. Start coding (say this each session)
"Read CLAUDE.md"

Upgrade

npm install -g codesyncer@latest

Core Features

🏷️ Tag System

Put context IN your code. AI reads code, so it recovers context automatically.

// @codesyncer-decision: [2024-01-15] Using JWT (session management is simpler)

…

View on GitHub

정리하면

	Gas Town	CodeSyncer
슬로건	Scale your agents	Remember your context
타겟	팀/엔터프라이즈	개인 개발자
에이전트	20-30개 동시	1개와 깊이
상태 저장	Git worktree	코드 주석

철학은 같습니다. "AI는 일시적이지만, 맥락은 영구적이어야 한다."

다만 타겟과 접근이 다를 뿐입니다.

마치며

2026년, AI 코딩의 진짜 승부처는 "더 똑똑한 모델"이 아니라 "더 나은 맥락 관리"라고 생각합니다.

Steve Yegge가 Gas Town으로 그 길을 보여줬고, 저도 개인 개발자를 위한 작은 기여를 해보려 합니다.

둘 다 오픈소스입니다. AI 코딩에 관심 있으신 분들, 한번 살펴보세요.

Gas Town - 팀/엔터프라이즈용
CodeSyncer - 개인 개발자용

비슷한 고민 하고 계셨다면 댓글로 공유해주세요!

AI 코딩이 자꾸 내 아키텍처를 망가뜨린다면? (feat. CodeSyncer)

@kiwibreaksme — Sat, 10 Jan 2026 10:49:13 +0000

요즘 Claude Code나 Cursor 같은 AI 코딩 도구 많이 쓰시죠? 저도 생산성이 엄청 올라서 애용하고 있습니다.

그런데 프로젝트 규모가 조금만 커져도(특히 멀티 레포나 모노레포에서) 이런 경험, 다들 한 번쯤 있으실 겁니다.

나: "사용자 프로필 수정 기능 좀 만들어줘."

AI: (뚝딱뚝딱 코드를 만듦) "여기 있습니다!"

나: (코드를 확인하며) "...???" 🤯

분명히 돌아가는 코드긴 한데...

이미 있는 공통 유틸 함수를 안 쓰고 똑같은 걸 새로 만들어놨거나,
비즈니스 로직을 UI 컴포넌트 안에 냅다 박아버렸거나,
src/features/user 폴더에 넣어야 할 파일을 뜬금없이 src/shared에 만들어놓는 등...

코드는 맞는데, 정작 중요한 프로젝트 아키텍처는 박살이 나 있는 상황, 겪어보셨죠?

🤔 도대체 왜 이러는 걸까요?

AI가 멍청해서가 아닙니다. AI에게는 '우리 프로젝트의 전체 지도(Context)'가 없기 때문입니다.

AI는 지금 열려있는 파일이나 내가 던져준 코드 조각만 보고 판단합니다. 내가 6개월 전에 정한 폴더 구조 규칙이나 컨벤션은 알 길이 없죠. 그래서 우리는 매번 새로운 세션을 시작할 때마다 이런 노가다를 반복합니다.

터미널에 tree 명령어 쳐서 복사하기
"우리 프로젝트 규칙은..." 하면서 장문의 텍스트 복붙하기
DB 스키마 파일 찾아서 열어주기

이 귀찮은 과정을 자동화할 수는 없을까요?

🚀 그래서 만들었습니다: CodeSyncer

AI에게 매번 수동으로 컨텍스트를 주입하는 게 너무 귀찮아서, 이 과정을 자동화하는 오픈소스 CLI 도구, CodeSyncer를 만들었습니다.

CodeSyncer의 핵심 기능

CodeSyncer는 복잡한 프로젝트 구조를 AI가 이해하기 쉬운 형태의 문서로 자동으로 만들어주는 '다리' 역할을 합니다.

1. 자동 문맥(Context) 생성

codesyncer init 명령어 한 방이면 프로젝트 전체 구조를 분석해서 AI가 읽을 수 있는 가이드 문서를 만들어줍니다. 싱글 레포는 물론, Turborepo나 Nx 같은 모노레포도 자동으로 인식합니다.

2. 실시간 감지 (Watch Mode)

코딩하면서 파일 구조가 바뀌면, codesyncer watch가 이를 실시간으로 감지해서 가이드 문서를 업데이트합니다. AI는 항상 최신 상태의 '지도'를 보게 됩니다.


bash
codesyncer watch
# ✨ Changed: src/utils/api.ts
# ✅ Context Updated

Stop AI From Ruining Your Architecture: 3 Context Strategies (And How to Automate Them)

@kiwibreaksme — Thu, 08 Jan 2026 11:07:32 +0000

We've all been there.

You ask Claude Code or Cursor to "add a user profile feature." The AI writes code instantly. It looks clean. It runs without errors.

But then you look closer... 😱

It created a new database connection instead of using your existing singleton.

It used axios when your whole project uses fetch.

It placed business logic inside a UI component.

The code works, but the architecture is broken.

The problem isn't that AI is stupid. The problem is that AI is context-blind. It sees the file you opened, but it doesn't see the decisions you made 6 months ago.

Here are 3 strategies to force AI to respect your architecture (and a tool I built to automate this).

Strategy 1: feed the "Map," Not Just the Code
AI hallucinates paths because it doesn't know your folder structure. Before asking for code, you need to provide a high-level map.

❌ Don't just say: "Create a service for payments." ✅ Do this: Run the tree command and paste it into your prompt.

Plaintext

/src
/core (Base classes)
/features (Domain logic)
/shared (Utils)
Why it works: When AI sees the tree, it understands that "Oh, business logic belongs in /features, not /shared."

Strategy 2: Define "Hard Constraints" (The NO List)
AI wants to please you, so it often takes shortcuts. You need to explicitly define what is forbidden. Create a "Rules" list.

NO direct database calls in controllers.

NO new npm packages without permission.

ALWAYS use the custom AppError class for exceptions.

If you don't enforce these, AI will default to generic internet tutorials (which are often outdated).

Strategy 3: The "Decision Log"
Code tells you what is happening, but not why. Why did we choose generic interfaces over direct typing? Why is this module isolated?

If you don't document the "Why", AI will refactor your "weird code" into "standard code," breaking your specific architectural goals. Keep a DECISIONS.md file that explains your architectural history.

😫 The Problem: "This is too much work"
Doing the above manually for every single AI session is exhausting.

Running tree every time you add a file?

Copy-pasting rules into every new chat?

Manually updating documentation?

This friction is why I built CodeSyncer.

🤖 Meet CodeSyncer: Automate Your Context
I created an open-source tool called CodeSyncer to automate these exact strategies.

It analyzes your project and generates a "Context Layer" that AI tools (Claude Code, Cursor, Copilot) can digest instantly.

Automated Architecture Mapping
Instead of running tree manually, CodeSyncer generates a MASTER_CODESYNCER.md that maps your entire repo (or monorepo). AI reads this to navigate your project without getting lost.
The "Safety Brake" System
CodeSyncer watches for dangerous keywords. If AI tries to touch critical code like Payment or Auth, CodeSyncer's rules trigger an auto-pause, forcing the AI to check your specific business constraints first.
Real-Time Watch Mode
As you code, CodeSyncer watches your files.

Bash

codesyncer watch
If you change the folder structure, it updates the documentation in real-time. Your AI assistant always has the latest map of your architecture.

🚀 Give it a try
If you want to stop fighting with AI over architecture and start shipping features that fit your design patterns, try adding CodeSyncer to your workflow.

Installation:

Bash

npm install -g codesyncer
Setup:

Bash

codesyncer init
Then, just tell your AI: "Read CLAUDE.md".

It's open-source and free. Let me know if it helps your workflow!

GitHub: github.com/bitjaru/codesyncer (Stars are appreciated! ⭐)

NPM: npmjs.com/package/codesyncer