케이스 스터디 · s19
01 / 14
← → SPACE 이동 · F 전체화면← → SPACE move · F fullscreen · s19 · CASE STUDY [email protected]
심화 & 종합 · 5단계Advanced & capstone · phase 5

케이스 스터디 —
이 강의 자체가 사례다.
Case study —
this course is the case.

s01~s18에서 배운 Rule들이 실제 현장에서 어떻게 작동하는가. 이론이 아니라 — 현장을 본다. 그리고 마지막 사례는 이 강의 자체다. How the Rules from s01–s18 play out in real settings. Not theory — we look at the field. And the last case is this course itself.

As of 2026-06 · 케이스 스터디 세션은 Rule 번호가 없는 캡스톤 강. s01~s18의 원리를 현장 사례로 연결한다. [추론]As of 2026-06 · Capstone session with no Rule number. Connects s01–s18 principles to real-world cases. [inference]

사례 · CASECASE
1막 — 이론을 배웠다, 이제 현장을 보자Act 1 — Theory learned; now the field

원칙은 현장에서 증명된다.Principles prove themselves in the field.

이론만 있을 때Theory alone

"알 것 같은데… 어떻게 적용하지?""I think I get it… but how do I apply it?"

현장 사례와 연결할 때Connected to a real case

"이 상황에선 Rule No.X를 쓴다.""In this situation, I use Rule No.X."

오늘의 목표: 원칙 → 상황 → 적용 → 결과의 흐름을 4가지 사례로 본다.Today's goal: see the flow of principle → situation → application → result in 4 cases.

[추론] 케이스 스터디의 목적은 원칙과 상황을 연결하는 것. 4개 사례: 코드베이스·문서·팀 인프라·이 강의 자체.[inference] The purpose of the case study is to connect principles to situations. 4 cases: codebase · docs · team infra · this course.

2막 — 케이스 1Act 2 — Case 1

대규모 코드베이스 리팩토링 — Rule No.9, 10, 14 적용.Large-scale codebase refactoring — Rule No.9, 10, 14 applied.

항목Item 내용Detail
문제Problem 수만 줄 코드, 한 번에 분석하면 컨텍스트 초과·품질 저하Tens of thousands of lines; analyzing at once exceeds context and degrades quality
접근법Approach 파일 단위로 분리, 단계별 검증, 병렬 분석Separate by file, stage-by-stage verification, parallel analysis
적용 RuleRules applied No.9 — 먼저 이해하고; No.10 — 작은 일로 쪼개기; No.14 — 서브에이전트 팀으로No.9 — understand first; No.10 — break into small tasks; No.14 — sub-agent team
결과Result 한 번에 실패했던 리팩토링을 단계적으로 완료, 오류 없이 통과Refactoring that failed all-at-once completed step-by-step, passing cleanly

[추론] 컨텍스트 초과와 자기검증 문제를 Rule No.9(맥락 파악 우선), No.10(작업 분해), No.14(멀티에이전트 병렬 분석)로 해결하는 일반 패턴. 구체 수치 없음.[inference] General pattern of solving context overflow and self-verification via Rule No.9 (understand first), No.10 (task decomposition), No.14 (multi-agent parallel analysis). No specific numbers.

2막 — 케이스 2Act 2 — Case 2

문서 자동화 파이프라인 — Rule No.5, 6, 13 적용.Documentation automation pipeline — Rule No.5, 6, 13 applied.

항목Item 내용Detail
문제Problem 코드 변경마다 문서 수동 업데이트 → 항상 뒤처지고 오류 발생. 처음엔 매번 "업데이트해 줘"라고 요청했지만 출력이 그때그때 달랐다.Manual doc update on every code change → always behind, errors creep in. First tried asking "update it" each time, but output varied every time.
접근법Approach 원하는 출력을 예시로 먼저 정의하고(No.6), 역할·형식·제약을 설계(No.5)한 뒤 파이프라인 자체를 환경으로 구성(No.13)Defined desired output by example first (No.6), then designed role/format/constraints (No.5), and built the pipeline itself as the environment (No.13)
적용 RuleRules applied No.5 — 명령하지 말고 설계하라 (형식·제약을 먼저 설계); No.6 — 예시가 설명보다 강하다 (출력 예시로 계약 고정); No.13 — 환경을 설계해라 (일꾼이 아닌 일터)No.5 — design, don't command (design format & constraints first); No.6 — examples beat explanations (pin the contract with output examples); No.13 — design the environment (workplace not worker)
결과Result 문서가 코드와 항상 동기화, 수동 작업 제거, 검증 자동화Docs always in sync with code, manual work eliminated, verification automated

[추론] No.5(역할·형식·제약 설계)를 반복 업무 환경(No.13)에 박아둔 패턴. "형식 고정"은 No.5의 형식 설계를 파이프라인(No.13)에 고정한 것. "일꾼을 더 잘 만드는 것"보다 "일터의 구조를 바꾸는 것"이 더 효과적인 유형.[inference] Pattern of embedding No.5 (role/format/constraint design) into a repeatable-work environment (No.13). "Format pinning" is No.5's format design locked into the pipeline (No.13). Changing the structure of the workplace outperforms making a better individual worker.

2막 — 케이스 3Act 2 — Case 3

팀 AI 활용 체계 구축 — Rule No.15, 16 적용.Team AI adoption framework — Rule No.15, 16 applied.

항목Item 내용Detail
문제Problem 팀원마다 다른 방식, AI 결과 신뢰 불일치, 검토 프로세스 없음. 처음엔 개인이 더 잘 쓰면 해결될 것이라 생각했지만 품질 편차가 줄지 않았다.Every team member works differently, inconsistent trust in AI output, no review process. Initially assumed better individual skill would fix it — but quality variance didn't shrink.
접근법Approach 검증 게이트를 시스템으로 설계(No.15), 실패 원인을 기록하고 팀 전체가 공유하는 거버넌스 구축(No.16)Designed verification gates as a system (No.15); built governance to record failures and share them across the team (No.16)
적용 RuleRules applied No.15 — 신뢰는 설계하는 것 (검증 게이트 내재화); No.16 — 개인 도구가 팀 인프라가 되려면 (실패 기록·공유 거버넌스)No.15 — trust is designed (bake in verification gates); No.16 — from personal tool to team infrastructure (failure-sharing governance)
결과Result 팀 전체가 같은 기준으로 검토, 실패 케이스 기록으로 동일 실수 재발 방지Whole team reviews to the same standard; failure case log prevents the same mistakes from recurring

[추론] 팀 단위 AI 도입에서 신뢰 설계(Rule No.15)와 팀 인프라 전환(Rule No.16 — 거버넌스·공유)이 개인 역량 편차보다 더 중요한 사례. 개인 노하우를 팀 자산으로 전환하는 것이 No.16의 핵심. 구체 팀 규모 없음.[inference] In team-level AI adoption, trust design (Rule No.15) and transitioning to team infrastructure (Rule No.16 — governance & sharing) matter more than individual skill variance. Converting individual know-how into team assets is the core of No.16. No specific team size.

2막 — 케이스 4 (자기 공개)Act 2 — Case 4 (self-disclosure)

이 강의는 Rule No.14로 만들어졌습니다 — 멀티에이전트로 20강 제작.This course was built with Rule No.14 — 20 lessons by multi-agent.

문제: 20강·다국어·슬라이드·내레이션을 혼자 만들면 → 컨텍스트 흐려지고 일관성 무너짐
해법: 오케스트레이터 + 전문 에이전트 팀으로 역할 분리
팀: 구조 감독 · 집필 · 슬라이드 · 팩트체크 · 발음검수 · 음성 · 다국어
결과: 20강 전체가 동일한 원칙·형식·근거 체계로 완성
Problem: build 20 lessons + multilingual + slides + narration solo → context fogs, consistency breaks
Solution: orchestrator + specialist agent team with split roles
Team: structure · writing · slides · fact-check · pronunciation · audio · i18n
Result: all 20 lessons completed with same principles, format & evidence system
RULE No.14

[추론] How_to_claude 코스는 오케스트레이터 + 7개 서브에이전트(구조 감독·집필·슬라이드·팩트체크·발음검수·음성·다국어)로 제작됐다. s14 자기 공개의 확장. As of 2026-06.[inference] The How_to_claude course was built by an orchestrator + 7 sub-agents (structure·writing·slides·fact-check·pronunciation·audio·i18n). Extension of s14 self-disclosure. As of 2026-06.

3막 — 패턴 분석Act 3 — Pattern analysis

성공한 사례에는 공통점이 있다.Successful cases share common traits.

  1. 1
    먼저 이해하고 쪼갰다Understood and decomposed first → 전체를 파악한 뒤 작은 단위로 분해했다→ grasped the whole, then broke it down
  2. 2
    형식을 미리 고정했다Pinned the format early → 결과 계약이 명확해야 합칠 수 있다→ a clear result contract makes combining safe
  3. 3
    검증을 만든 자에게 맡기지 않았다Didn't hand verification to the maker → 생산자-검증자를 분리했다→ producer and verifier were split
  4. 4
    실패를 기록했다Documented failures → 한 번 실패한 패턴이 반복되지 않았다→ patterns that failed once didn't repeat

[추론] 네 케이스에서 반복 등장하는 성공 패턴 4가지. 이해 우선·형식 고정·생산자-검증자 분리·실패 자산화는 각각 Rule No.9, No.5·6, No.14·15, No.16과 대응.[inference] Four success patterns recurring across the four cases. Understanding first·pinning format·splitting producer-verifier·asset-making from failures correspond to Rule No.9, No.5·6, No.14·15, No.16 respectively.

3막 — 실패 패턴Act 3 — Failure patterns

실패 사례에도 공통점이 있다.Failed cases also share patterns.

실패 패턴Failure patterns
  • 한 번에 너무 많이 → 컨텍스트 흐림Too much at once → context fogs
  • 형식 없이 출력 → 합칠 수 없는 결과Output without format → can't combine
  • 자기검증 → 편향된 통과Self-verification → biased pass
  • 실패 무시 → 같은 오류 반복Ignoring failures → same errors repeat
공통 원인Common root cause
  • 설계보다 실행을 먼저 했다Execution before design
  • "더 좋은 프롬프트"로 해결하려 했다Tried to fix with "a better prompt"
  • 시스템이 아니라 개인 기술에 의존했다Relied on individual skill, not a system

[추론] 실패 패턴 4가지: 컨텍스트 과부하·형식 미설계·자기검증·실패 무시. 공통 원인: "설계 없이 실행", "프롬프트 최적화 신화", "시스템 아닌 개인 의존". Rule No.2·No.5·6·No.14·No.16의 부재.[inference] Four failure patterns: context overload·no format designed·self-verification·ignoring failures. Common root: execution without design, prompt-optimization myth, relying on individual not system. Absence of Rule No.2·No.5·6·No.14·No.16.

3막 — Rule 조합 전략Act 3 — Rule combination strategy

Rules는 혼자 작동하지 않는다 — 조합이 힘이다.Rules don't work alone — combinations are the power.

상황Situation 핵심 Rule 조합Core Rule combination
복잡한 작업 분해Decomposing complex work No.9 + No.10 + No.14
반복 가능한 출력Repeatable output No.5 + No.6 + No.13
팀 품질 관리Team quality control No.15 + No.16
장기 프로젝트Long-running project No.2 + No.14 + No.15 + No.16

[추론] Rule 조합 패턴은 케이스들에서 귀납된 경험 법칙. "항상 이 조합이 맞다"는 단정 불가 — 자기 상황에 맞게 조정 필요. 조합을 찾는 능력 자체가 숙련의 증거.[inference] Rule combination patterns are rules of thumb induced from the cases. No fixed "this combination is always right" — adjustment to one's own situation required. The ability to find the right combination is itself a sign of mastery.

3막 — 상황별 Rule 선택Act 3 — Rule selection by situation

어떤 상황에서 어떤 Rule부터 꺼내나.Which Rule to reach for, in which situation.

  1. 1
    컨텍스트가 흐려지고 있다Context is getting foggy → Rule No.2 (컨텍스트를 보호하라)→ Rule No.2 (protect context)
  2. 2
    출력이 매번 다르다Output varies every time → Rule No.5 (명령하지 말고 설계하라 — 형식·제약을 먼저 설계)→ Rule No.5 (design, don't just command — design the format & constraints first)
  3. 3
    팀이 AI 결과를 믿지 못한다Team doesn't trust AI output → Rule No.15 (신뢰는 설계하는 것)→ Rule No.15 (trust is designed)
  4. 4
    같은 실수가 반복된다The same mistakes keep repeating → Rule No.16 (개인 도구가 팀 인프라가 되려면 — 실패 기록·공유 거버넌스)→ Rule No.16 (from personal tool to team infrastructure — build failure-sharing governance)

[추론] 상황을 진단하고 첫 번째로 꺼낼 Rule을 연결하는 실전 가이드. "첫 Rule"은 출발점이며 반드시 다른 Rules와 조합 필요. 모든 상황을 망라하지 않음.[inference] A practical guide linking situation diagnosis to the first Rule to reach for. The "first Rule" is a starting point — must be combined with other Rules. Does not cover every situation.

4막 — 실천Act 4 — Practice

가장 좋은 케이스는 내 것이다.The best case is your own.

  1. 1
    최근 AI와 함께 한 작업 중 가장 잘된 것 하나를 고른다Pick one thing from recent AI work that went really well
  2. 2
    문제 → 접근법 → 적용한 Rule → 결과를 한 장으로 정리한다Summarize on one page: problem → approach → Rules applied → result
  3. 3
    다음에 같은 상황이 오면 재현할 수 있는지 점검한다Check whether you can reproduce it when the same situation comes again
  4. 4
    팀이 있으면 공유한다 (남의 케이스도 내 자산이다)If you have a team, share it (someone else's case is your asset too)

[추론] 케이스를 자기 경험으로 만드는 4단계. 재현 가능성이 핵심 — "한 번 잘 됐다"는 경험이 아니라 "다음에도 쓸 수 있는 패턴"을 추출하는 것.[inference] Four steps to make a case your own experience. Reproducibility is the key — not "it worked once" but "a pattern I can use next time."

4막 — 자가진단Act 4 — Self-assessment

지금 내가 가장 적게 쓰는 Rule은 어디인가.Which Rule am I using least right now?

  1. s01–05
    컨텍스트 관리Context management → 흐려지는 일이 자주 있나?→ does it get foggy often?
  2. s06–10
    프롬프트·구조 설계Prompt & structure design → 형식 없이 출력받는 일이 있나?→ do you receive output without a format?
  3. s11–14
    에이전트·팀Agent & team → 혼자 몰아서 쓰는 패턴이 있나?→ do you have a pattern of piling everything on one?
  4. s15–18
    신뢰·평가Trust & evaluation → 검증 없이 그냥 쓰는 경우가 있나?→ do you ever use output without verifying?

약한 곳 하나를 골라 다음 주에 집중한다.Pick one weak area and focus on it next week.

[추론] s01~s18을 4개 블록으로 묶어 자가진단 프레임. "전부 잘해야 한다"가 아니라 "약한 곳 하나를 고른다".[inference] Groups s01–s18 into 4 blocks as a self-assessment frame. Not "you must do everything well" but "pick one weak spot."

4막 — 팀 공유Act 4 — Team sharing

혼자 배운 것은 나만 좋아진다 — 팀이 배우면 시스템이 좋아진다.Solo learning only improves you — team learning improves the system.

혼자 쌓을 때Building alone
그 사람이 없으면 사라진다
팀의 평균이 안 올라간다
disappears when that person leaves
team average doesn't rise
팀이 공유할 때Team sharing
케이스가 공유 자산이 된다
시스템이 시간이 갈수록 좋아진다
cases become shared assets
the system improves over time

최소한 한 달에 한 번 — 내 케이스 하나를 팀에 공개한다.At least once a month — share one of your cases with the team.

[추론] 케이스 공유는 Rule No.16(개인 도구가 팀 인프라가 되려면)의 실천 — 개인이 쌓은 패턴을 팀 거버넌스로 전환하는 것. "한 달에 한 번" 빈도는 추론이지 규정이 아님.[inference] Case sharing is the practice of Rule No.16 (from personal tool to team infrastructure) — converting individually accumulated patterns into team governance. "Once a month" frequency is inference, not a rule.

닫으며 · 이 강의가 사례였다Closing · this lesson was the case

이론이 현장에서 증명될 때 —
비로소 실력이 된다.
When theory proves itself in the field —
that's when it becomes real skill.

케이스 = 문제 + 접근법 + Rule + 결과. 재현 가능하면 내 패턴이 된다.
이 강의 자체가 Rule No.14의 실전 사례 — 멀티에이전트로 20강을 만들었다.
Case = problem + approach + Rule + result. Reproducible = your pattern.
This lesson itself was the real-world case of Rule No.14 — 20 sessions by multi-agent.

다음 강 — s20 종합 & 미래: 20강의 Rule을 하나의 지도로 완성한다. Next — s20 synthesis & future: completing all 20 Rules as one unified map.

CASE STUDY

[추론] 케이스 스터디 세션의 핵심: 이론→현장→내 패턴으로의 전이. Rule No.14 자기 공개(멀티에이전트 산물). s20: 20개 Rule을 하나의 통합 지도로 마무리. As of 2026-06.[inference] Core of the case study session: theory → field → my pattern. Rule No.14 self-disclosure (multi-agent product). s20: wrapping up 20 Rules as one integrated map. As of 2026-06.

강의 노트Lecture notes

19강 · 케이스 스터디Lesson 19 · Case Study

s01~s18에서 배운 Rule들이 실제 현장에서 어떻게 작동하는가 — 이론이 아니라 현장을 본다How the Rules from s01–s18 play out in real settings — not theory, the field

강의 요약Summary

지금까지 우리는 Rule No.1부터 No.18까지, 원칙과 메커니즘을 하나씩 배웠습니다. 하지만 원칙만 배우면 늘 이런 느낌이 남습니다 — "알 것 같은데, 실제로 어떻게 써야 하지?" 19강은 이론과 현장 사이의 그 거리를 좁히는 시간입니다. 대규모 매출 데이터 분석, 보고서 자동화 파이프라인, 팀 AI 활용 체계 구축, 그리고 이 코스 자체까지 — 네 가지 실전 사례를 통해 배운 Rule들이 어떤 상황에서, 어떤 조합으로, 어떤 결과를 만들어 냈는지를 살펴봅니다.So far we've worked through Rule No.1 to No.18, one principle and mechanism at a time. But learning principles alone always leaves a feeling: "I think I understand it, but how do I actually use it?" Lesson 19 is about closing that gap between theory and the field. Through four real cases — large-scale sales data analysis, a report automation pipeline, a team AI adoption framework, and this course itself — we look at which situations the Rules applied to, in what combinations, and with what results.

네 사례 모두, 처음엔 "그냥 통째로 시켜보는" 방식으로 실패했습니다. 매출 데이터는 컨텍스트가 넘쳐서 앞의 결정이 뒤에서 잊혔고(Rule No.2, No.10), 보고서는 매번 형식이 달라 다음 사람이 쓸 수 없었고(Rule No.5, No.6, No.13), 팀의 AI 활용은 사람마다 검토 수준이 달라 "이 결과를 믿을 수 있나"라는 질문이 반복됐습니다(Rule No.15, No.16). 실패를 살펴보면 뿌리는 하나였습니다 — 설계보다 실행을 먼저 했다는 것. "더 좋은 프롬프트를 쓰면 해결되겠지"라는 생각은 임시방편일 뿐, 근본 해법은 누가 써도 일정 수준 이상이 나오는 시스템을 만드는 것이었습니다.All four cases first failed the same way — handing over the whole job at once and saying "just do it." The sales data overflowed context so early decisions got forgotten later (Rule No.2, No.10); the report's format changed every time so the next person couldn't use it (Rule No.5, No.6, No.13); and the team's AI use varied in review rigor person to person, so "can we trust this?" kept coming up (Rule No.15, No.16). Look at the failures and the root is one thing: execution came before design. The instinct "a better prompt will fix it" is only a patch — the real fix is building a system that clears a consistent bar no matter who runs it.

성공한 쪽에는 네 가지 공통점이 있었습니다. 먼저 전체를 이해하고 작은 일들로 쪼갰고, 결과물의 형식을 실행 전에 미리 고정했고, 검증을 만든 사람에게 맡기지 않고 별도 단계로 분리했고, 실패를 그냥 넘기지 않고 기록해 자산으로 남겼습니다. 그리고 어떤 사례도 Rule 하나만으로 해결되지 않았습니다 — 항상 두세 개가 조합으로 작동했습니다. 복잡한 작업 분해엔 No.9·10·14가, 반복 가능한 출력엔 No.5·6·13이, 팀 품질 관리엔 No.15·16이 함께 왔습니다.The successes shared four traits: they understood the whole picture and decomposed it into small tasks first; they pinned the output format before execution; they separated verification into its own step instead of leaving it to the maker; and they didn't brush past failure — they documented it as an asset. And no case was solved by a single Rule alone — it was always two or three working in combination. Decomposing complex work brought No.9, 10, and 14 together; repeatable output needed No.5, 6, and 13; team quality control ran on No.15 and 16 together.

그리고 오늘 가장 중요한 사례는 사실 이 강의 자체였습니다. 스무 개 세션, 두 개 언어, 슬라이드·내레이션·실험까지 아우르는 이 How_to_claude 코스는 한 세션, 한 명에게 통째로 맡겼다면 형식이 강마다 흔들리고 근거 태그가 흐려졌을 겁니다. 그래서 Rule No.14를 그대로 적용해, 오케스트레이터 한 명과 일곱 개 전문 팀으로 만들었습니다. 원리를 가르치는 강의가 그 원리로 만들어진 것 — 이게 오늘 배울 가장 실감 나는 증거입니다.And the most important case today was actually this course itself. How_to_claude spans twenty sessions, two languages, slides, narration, and experiments — if all of it had been handed to one worker in one session, the format would have drifted lesson to lesson and evidence tags would have faded. So Rule No.14 was applied as-is: one orchestrator and seven specialist teams built it. A lesson that teaches a principle was itself built by that principle — that's the most tangible proof you'll see today.

핵심 교훈 5가지Five key takeaways

  1. 01

    큰 일은 먼저 이해하고 쪼갠다Understand big work first, then decompose it

    수만 건의 매출 데이터를 통째로 넘기고 "분석해 줘"라고 하면, 컨텍스트가 넘치고 앞선 결정이 뒤에서 잊히고 같은 패턴인데 처리가 달라집니다. 해법은 순서였습니다 — Rule No.9로 전체 구조와 의존성을 먼저 파악하고, Rule No.10으로 카테고리·기간 단위로 쪼개 단계마다 검증하고, Rule No.14로 서로 의존하지 않는 작업은 서브에이전트 팀에게 병렬로 맡깁니다. 한 번에 실패하던 작업이 단계적으로 완료되고 오류 없이 통과했습니다.Hand over tens of thousands of sales rows all at once and say "analyze this," and context overflows, earlier decisions get forgotten later, and identical patterns get processed inconsistently. The fix was sequencing: Rule No.9 to map the whole structure and dependencies first, Rule No.10 to split by category and time period with validation at each stage, and Rule No.14 to hand independent chunks to a sub-agent team running in parallel. Work that failed all at once completed step by step and passed cleanly.

  2. 02

    형식은 결과를 받기 전에 고정한다Lock the format before you get the output

    데이터가 바뀔 때마다 "보고서 업데이트해 줘"라고 매번 요청하면, 그때그때 출력이 달라 다음 사람이 쓸 수 없습니다. 이건 일꾼을 반복 사용하는 것이지 문제를 근본적으로 푸는 게 아닙니다. 해법은 Rule No.5로 원하는 형식을 제약으로 먼저 설계하고, Rule No.6으로 실제 출력 샘플을 보여줘 형식 계약을 고정하고, Rule No.13으로 데이터가 갱신될 때마다 자동으로 보고서가 생성·검증되는 환경 자체를 만드는 것이었습니다. 결과는 데이터와 항상 동기화되는 보고서, 그리고 사라진 수동 작업입니다.Asking "update the report" fresh every time the data changes produces a different output each time, so the next person can't rely on it. That's repeatedly using a worker, not solving the root problem. The fix: Rule No.5 designs the desired format as a constraint up front, Rule No.6 shows an actual sample output to lock the format contract, and Rule No.13 builds the environment itself so reports auto-generate and auto-verify whenever data updates. The result: reports always in sync with the data, and manual work gone.

  3. 03

    신뢰는 우기지 말고 설계한다Design trust — don't just insist on it

    팀원마다 AI를 쓰는 방식이 달라 결과 품질이 들쭉날쭉하고, "이 결과를 믿을 수 있나?"라는 질문이 매번 나온다면 이건 개인 역량 문제가 아니라 신뢰를 설계하지 않은 문제입니다. Rule No.15는 AI 결과가 팀 업무에 쓰이기 전에 통과해야 하는 검증 게이트를 팀 공통 체크리스트로 만드는 것입니다. 신뢰는 개인이 "더 잘 쓰면" 생기는 게 아니라 시스템으로 만들어야 생깁니다.If team members use AI differently and result quality swings wildly, with "can we trust this?" coming up every time, that's not a skill problem — it's the problem of not designing trust. Rule No.15 turns this into a team-shared verification checklist: a trust gate that AI output must clear before it's used in team work. Trust doesn't appear because individuals "get better at it" — it has to be built into the system.

  4. 04

    개인 노하우를 팀 자산으로 전환한다Convert personal know-how into team assets

    잘못된 결과가 나왔을 때 그냥 고치고 넘어가면 같은 실수가 반복됩니다. Rule No.16은 왜 실패했는지를 기록하고 팀 전체가 공유하는 거버넌스를 만드는 것입니다. 자기채점은 항상 관대하기 때문에, 검증을 만든 사람에게 맡기지 않는 원칙과도 이어집니다. 최소한 한 달에 한 번, 자신의 케이스 하나를 팀에 공개하는 것만으로도 팀의 집단 지식이 쌓이고, 팀원의 케이스가 여러분의 자산이 됩니다.Just fixing bad output and moving on means the same mistake repeats. Rule No.16 is about documenting why something failed and building governance so the whole team shares it. Because self-grading is always generous, this connects to the same principle of never handing verification to the maker. Sharing even just one case with the team once a month builds collective knowledge, and your teammates' cases become your assets in return.

  5. 05

    Rule은 조합으로 작동하고, 이 강의 자체가 증거다Rules work in combination — and this course is the proof

    네 사례 어디에도 Rule 하나만 쓴 경우는 없었습니다. 복잡한 작업 분해엔 No.9·10·14가, 반복 가능한 출력엔 No.5·6·13이, 팀 품질 관리엔 No.15·16이 함께 작동했습니다. 그리고 이 조합을 가장 크게 보여준 건 이 코스 자체입니다. 스무 개 세션, 두 언어, 슬라이드·내레이션·실험을 다루는 이 프로젝트는 Rule No.14를 그대로 적용해 오케스트레이터 한 명과 일곱 개 전문 팀 — 구조·집필·슬라이드·팩트체크·발음검수·음성·다국어 — 으로 만들어졌습니다. 원리를 가르치는 강의가 그 원리로 완성된 것, 이것이 오늘의 가장 실감 나는 사례입니다.No case relied on a single Rule alone. Decomposing complex work brought No.9, 10, and 14 together; repeatable output needed No.5, 6, and 13; team quality control ran on No.15 and 16. And the biggest demonstration of that combination is this course itself. Spanning twenty sessions, two languages, slides, narration, and experiments, this project applied Rule No.14 as-is — one orchestrator and seven specialist teams: structure, writing, slides, fact-checking, pronunciation QA, audio, and localization. A lesson teaching a principle, completed by that same principle — that's today's most tangible case.

실습 예제Exercise

오늘 본 네 가지 사례는 강사의 것입니다. 여러분에게 가장 유용한 케이스는 여러분 자신의 것이에요. 코드도 설정도 필요 없습니다 — 최근 AI와 함께 한 작업 중 가장 잘 됐던 것 하나를 골라, 아래 지시문으로 Claude와 함께 "문제 · 접근법 · 적용한 Rule · 결과"의 한 장짜리 케이스로 정리해 봅니다. 그리고 그게 재현 가능한지, 팀과 공유할 만한지까지 함께 점검합니다.The four cases you saw today belong to the instructor. The most useful case for you is your own. No code, no config needed — pick one recent piece of AI-assisted work that went really well, and use the instruction below to work with Claude to turn it into a one-page case covering "problem · approach · Rules applied · result." Then check together whether it's reproducible and worth sharing with your team.

복사해서 Claude 대화창에 붙여넣기Copy & paste into a Claude chat

다음 세 가지를 순서대로 해줘. ## 1단계 — 케이스 정리 최근에 나(사용자)가 AI와 함께 한 작업 중 가장 잘 됐다고 느낀 걸 하나 물어봐줘. 그리고 그 내용을 다음 네 항목으로 정리해줘: (1) 문제가 무엇이었는지, (2) 어떻게 접근했는지, (3) 어떤 Rule 또는 원칙이 작동한 것 같은지 (Claude Code No.1~No.18 중에서 짚어봐도 좋고, 없으면 일반 원칙으로 설명해도 돼), (4) 결과가 어땠는지. 추측하지 말고, 내가 답한 내용만 근거로 써. ## 2단계 — 재현 가능성 점검 정리한 케이스를 보고, "이게 다음에 같은 상황이 와도 같은 접근법으로 재현 가능한가"를 냉정하게 판단해줘. 재현 가능하다면 무엇 덕분인지, 재현이 어렵다면 무엇이 "운"에 가까웠는지 구분해서 말해줘. ## 3단계 — 팀 공유용 한 문단 이 케이스를 팀 동료에게 공유한다면 어떻게 한 문단으로 요약할지 써줘. 상황, 통한 접근법, 다음에 다르게 할 점을 포함해줘.

  1. 던지기: Claude 대화창을 열고 위 지시문을 그대로 붙여 넣는다. 1단계에서 Claude가 질문을 통해 내 작업을 문제·접근법·Rule·결과 네 요소로 분해해 주는지 확인한다. 이 네 요소가 바로 오늘 배운 "케이스"의 정의다.Throw it: Open a Claude chat and paste the instruction above. In step 1, check whether Claude's questions decompose your work into the four elements — problem, approach, Rule, result. Those four elements are exactly today's definition of a "case."
  2. 재현성 점검: 2단계에서 Claude가 "운"이었던 부분과 "재현 가능한 패턴"이었던 부분을 구분해 주는지 본다. "한 번 잘 됐다"는 재현 가능할 때만 진짜 케이스가 된다는 게 오늘의 핵심이다.Check reproducibility: In step 2, see whether Claude separates what was "luck" from what was a "reproducible pattern." Today's core point: something that "worked once" only becomes a real case when it's reproducible.
  3. 공유 준비: 3단계에서 나온 한 문단을 실제로 팀 채널이나 문서에 공유해 본다. 케이스를 혼자만 갖고 있으면 내가 팀을 떠나는 순간 사라지지만, 공유하면 팀 전체의 자산이 된다 — 이게 Rule No.16이 실무에서 시작되는 가장 작은 첫걸음이다.Prepare to share: Actually post the paragraph from step 3 to a team channel or doc. A case kept to yourself disappears the moment you leave the team; shared, it becomes an asset for everyone — the smallest first step of putting Rule No.16 into practice.

전체 대본Full transcript

1 · 도입 — 케이스 스터디1 · Intro — Case study

안녕하세요. 드디어 스무 강 중 열아홉 번째에 왔습니다. 이번 강의 제목은 "케이스 스터디 — 이 강의 자체가 사례다"입니다. 지금까지 우리는 룰 넘버 원부터 룰 넘버 에이틴까지, 원칙과 메커니즘을 배웠죠. 오늘은 그 원칙들이 실제 현장에서 어떻게 작동했는지, 네 가지 사례로 살펴봅니다. 그리고 네 번째 사례는 조금 특별합니다. 바로 여러분이 지금 보고 있는 이 강의 자체예요.Welcome. We've reached lesson nineteen of twenty. Today's title: "Case study — this course is the case." So far we've worked through Rules from Number One to Number Eighteen — principles and mechanisms. Today we look at how those principles played out in four real cases. And the fourth case is a little special: it's this course itself, the one you're watching right now.

2 · 원칙은 현장에서 증명된다2 · Principles proven in the field

원칙만 배우면 이런 느낌이 들 때가 있죠. "알 것 같은데, 실제로 어떻게 써야 하지?" 이건 이론을 배운 것과 현장에서 쓸 수 있는 것 사이의 거리예요. 오늘은 그 거리를 줄이는 시간입니다. 우리가 배운 Rules가 실제 어떤 상황에서, 어떤 조합으로, 어떤 결과를 만들어 냈는지. 네 가지 사례로 보겠습니다.When you learn principles alone, sometimes there's this feeling: "I think I understand it, but how do I actually use it?" That's the gap between knowing theory and being able to use it in the field. Today is about closing that gap. We'll look at which situations our Rules applied to, in which combinations, and with what results — through four cases.

오늘의 사례는 이렇습니다. 첫 번째는 대규모 매출 데이터 분석. 두 번째는 보고서 자동화 파이프라인. 세 번째는 팀 AI 활용 체계 구축. 그리고 네 번째는 이 하우 투 클로드 코스 자체입니다. 각 사례마다 문제, 접근법, 적용한 Rule, 그리고 결과를 보겠습니다.Here are today's cases. First: large-scale sales data analysis. Second: report automation pipeline. Third: team AI adoption framework. And fourth: this very How_to_claude course. For each case we'll cover the problem, the approach, the Rules applied, and the result.

3 · 케이스 1 — 대규모 매출 데이터 분석3 · Case 1 — Large-scale sales data analysis

첫 번째 케이스입니다. 수만 건의 매출 데이터를 분석해야 하는 상황이에요. 처음에는 전체를 한꺼번에 넘기고 "분석해 줘"라고 했습니다. 그런데 컨텍스트가 넘치고, 앞에서 한 결정이 뒤에서 잊혀지고, 같은 패턴인데 처리가 달라지는 문제가 생겼어요. 이건 두 번째 강에서 배운 컨텍스트 로트, 그리고 열 번째 강에서 배운 작업 분해 없이 덤볐을 때 생기는 전형적인 실패입니다.The first case: a sales dataset with tens of thousands of rows that needs analysis. The first attempt was to hand the whole thing over and say "analyze this." But the context overflowed, decisions made early were forgotten later, and the same patterns ended up processed differently. This is the classic failure of context rot from lesson two, and of charging in without the task decomposition from lesson ten.

그래서 접근법을 바꿨습니다. 룰 넘버 나인, 먼저 이해하고. 전체 구조와 의존성을 파악하는 것부터 시작했어요. 그다음 룰 넘버 텐, 작은 일들로 쪼개기. 카테고리·기간 단위로 나눠서 순서를 정하고, 각 단계마다 검증을 거쳤습니다. 마지막으로 룰 넘버 포틴, 서브에이전트 팀으로. 서로 의존하지 않는 데이터 집합은 병렬로 분석해서 속도를 높였어요. 한 번에 실패했던 작업이 단계적으로 완료됐고, 오류 없이 통과했습니다.So the approach changed. Rule Number Nine: understand first. It started by mapping the whole structure and dependencies. Then Rule Number Ten: break into small tasks. Split by category and time period, ordered the steps, and validated at each stage. Finally Rule Number Fourteen: sub-agent team. Datasets that didn't depend on each other were analyzed in parallel for speed. The work that failed all at once completed step by step, and passed cleanly.

4 · 케이스 2 — 보고서 자동화 파이프라인4 · Case 2 — Report automation pipeline

두 번째 케이스는 보고서 자동화 파이프라인입니다. 데이터가 바뀔 때마다 보고서를 손으로 업데이트하면, 언제나 보고서가 뒤처지고 오류가 생깁니다. 처음에는 클로드한테 "보고서 업데이트해 줘"라고 매번 요청했어요. 그런데 이건 일꾼을 반복 사용하는 거지, 문제를 근본적으로 푸는 게 아니에요. 출력이 매번 다르고, 형식이 통일되지 않고, 다음 사람이 쓸 수 없었습니다.The second case is a report automation pipeline. Every time the data changes, manual report updates mean reports are always behind and errors creep in. The first approach was to ask Claude to "update the report" each time. But that's repeatedly using a worker — it doesn't solve the underlying problem. Output varied each time, format wasn't consistent, and the next person couldn't use it reliably.

그래서 먼저 룰 넘버 파이브, 명령하지 말고 설계하라. 보고서가 어떤 형식이어야 하는지를 제약으로 먼저 설계했습니다. 그리고 룰 넘버 식스, 예시가 설명보다 강하다. 원하는 출력 샘플을 직접 보여줘서 형식 계약을 명확히 고정했어요. 마지막으로 룰 넘버 서틴, 환경을 설계해라. 클로드를 일꾼으로 반복 쓰는 게 아니라, 데이터가 갱신될 때마다 자동으로 보고서가 생성되고 검증되는 파이프라인 자체를 설계했어요. 결과는요. 보고서가 데이터와 항상 동기화되고, 수동 작업이 사라지고, 형식 위반이 생기면 자동으로 걸러졌습니다.So first, Rule Number Five: design, don't just command. The output format was designed as a constraint up front — what the report had to look like was defined before anything else. Then Rule Number Six: examples beat explanations. A sample output was shown directly to lock in the format contract clearly. And finally Rule Number Thirteen: design the environment. Instead of repeatedly using Claude as a worker, the design shifted to a pipeline that automatically generates and verifies reports whenever the data is updated. The result: reports always in sync with data, manual work gone, and format violations caught automatically.

5 · 케이스 3 — 팀 AI 활용 체계 구축5 · Case 3 — Team AI adoption framework

세 번째 케이스는 팀 AI 활용 체계 구축입니다. AI 도구를 팀에 도입할 때, 팀원마다 쓰는 방식이 달라서 결과 품질이 들쭉날쭉하고, "이 결과를 믿을 수 있나?" 하는 질문이 매번 나왔어요. 누군가는 검토를 철저히 하고, 누군가는 그냥 씁니다. 이건 개인 역량 문제가 아니에요. 신뢰를 설계하지 않은 문제입니다.The third case is building a team AI adoption framework. When introducing AI tools to a team, different members used them differently, so result quality was inconsistent, and the question "can we trust this output?" came up every time. Some people reviewed thoroughly, others just used the output as-is. This isn't a skill problem — it's the problem of not designing trust.

그래서 룰 넘버 피프틴, 신뢰는 설계하는 것. AI가 생성한 결과물이 팀 업무에 쓰이기 전에 통과해야 하는 검증 게이트를 팀 공통 체크리스트로 만들었습니다. 그리고 룰 넘버 식스틴, 개인 도구가 팀 인프라가 되려면. 잘못된 결과가 나왔을 때 그냥 고치고 넘어가는 게 아니라, 왜 실패했는지를 기록하고 팀 전체가 공유하는 거버넌스를 만든 겁니다. 개인이 혼자 쌓은 노하우를 팀 자산으로 전환하는 것, 그게 룰 넘버 식스틴의 핵심이에요. 결과는요. 팀 전체가 같은 기준으로 AI 결과를 검토하게 됐고, 같은 실수가 반복되는 일이 크게 줄었습니다.So: Rule Number Fifteen, trust is designed. A team-shared verification checklist was created — a trust gate that AI-generated output must pass before being used in team work. And Rule Number Sixteen, from personal tool to team infrastructure. When bad output appeared, instead of just fixing and moving on, the team built governance to document why it failed and share it across the team. Converting individually held know-how into shared team assets — that's the core of Rule Number Sixteen. The result: the whole team reviewing AI output to the same standard, and the same mistakes recurring far less often.

6 · 케이스 4 — How_to_claude 코스 자체6 · Case 4 — The How_to_claude course itself

네 번째 케이스는 조금 다릅니다. 제가 직접 만든 이 강의 자체예요. 하우 투 클로드 코스는 스무 개의 세션, 한국어와 영어, 슬라이드, 내레이션, 그리고 실험까지 포함하는 큰 프로젝트입니다. 만약 이 모든 걸 하나의 세션에서, 한 명한테 다 시켰다면 어떻게 됐을까요? 앞에서 정한 원칙이 뒤에서 흐려지고, 슬라이드 형식이 강마다 달라지고, 근거 태그가 어느 순간부터 사라지겠죠.The fourth case is a little different. It's this course I made myself. The How_to_claude course is a large project — twenty sessions, Korean and English, slides, narration, and experiments included. What would have happened if all of that were assigned to one worker in a single session? The principles set early would have gotten foggy later, slide formats would have varied from lesson to lesson, and evidence tags would have disappeared at some point.

그래서 룰 넘버 포틴을 그대로 적용했습니다. 오케스트레이터 한 명과 일곱 개의 전문 팀. 구조를 감독하는 팀, 집필하는 팀, 슬라이드를 만드는 팀, 팩트를 체크하는 팀, 발음을 검수하는 팀, 음성을 다루는 팀, 그리고 다국어를 맞추는 팀입니다. 결과는 지금 보시는 이 강의예요. 스무 강 전체가 같은 원칙, 같은 형식, 같은 근거 체계로 완성됐습니다. 이 강의가 룰 넘버 포틴의 실전 사례입니다.So Rule Number Fourteen was applied as-is. One orchestrator and seven specialist teams: a structure team, a writing team, a slides team, a fact-check team, a pronunciation team, an audio team, and a localization team. The result is the course you're watching right now. All twenty lessons completed with the same principles, same format, and same evidence system. This course is the real-world case of Rule Number Fourteen.

7 · 패턴 분석 1 — 성공 사례의 공통점7 · Pattern 1 — Traits of success

네 가지 사례를 돌아보면 성공한 쪽에는 공통점이 있습니다. 첫째, 먼저 이해하고 쪼갰어요. 전체를 파악하지 않고 바로 작업에 뛰어들면 나중에 방향이 틀어집니다. 둘째, 형식을 미리 고정했어요. 결과가 어떤 모양이어야 하는지를 먼저 정해야, 나중에 결과들을 안전하게 합칠 수 있거든요.Looking back at the four cases, the successful ones share common traits. First: they understood and decomposed first. Diving into the work without grasping the whole leads to misalignment later. Second: they pinned the format early. You need to define what the output should look like before you can safely combine results later.

셋째, 검증을 만든 자에게 맡기지 않았어요. 만든 사람이 자기 걸 검토하면 약점이 잘 안 보입니다. 별도의 검증 단계가 있어야 품질이 유지됩니다. 그리고 넷째, 실패를 기록했어요. 같은 실수를 두 번 하는 건 기록의 문제예요. 실패 케이스를 자산으로 만들면, 시스템이 시간이 갈수록 더 좋아집니다. 이 네 가지가 성공한 사례들의 공통된 뼈대였습니다.Third: they didn't hand verification to the maker. The person who made it can't easily see its own weak spots — a separate verification step is what keeps quality up. And fourth: they documented failures. Repeating the same mistake twice is a documentation problem. Turn failure cases into assets and the system gets better over time. These four were the shared skeleton of the successful cases.

8 · 패턴 분석 2 — 실패 패턴8 · Pattern 2 — Failure patterns

반대로 실패한 쪽을 보면 패턴도 있습니다. 첫째, 한 번에 너무 많이 넘겼어요. 컨텍스트가 차서 흐려지는 건 시간 문제입니다. 둘째, 형식 없이 출력을 받았어요. 결과가 매번 다른 모양이면 나중에 합칠 수가 없어요. 셋째, 만든 쪽에 검증을 맡겼어요. 자기채점은 항상 관대합니다. 넷째, 실패를 그냥 넘겼어요. 기록하지 않으면 같은 실수가 반복됩니다.Looking at the failures, there are patterns there too. First: too much at once. Context filling and fogging is only a matter of time. Second: output received without a format. If the result looks different each time, you can't combine them later. Third: verification handed to the maker. Self-grading is always generous. Fourth: failures just brushed past. Without documentation, the same mistakes repeat.

그런데 이 네 가지 실패의 뿌리는 사실 하나예요. 설계보다 실행을 먼저 한 겁니다. "더 좋은 프롬프트를 쓰면 해결되겠지"라고 생각한 거죠. 그런데 프롬프트 최적화는 임시방편이에요. 근본 문제는 시스템의 부재입니다. 개인 기술이 좋아지는 게 아니라, 누가 써도 일정 수준 이상이 나오는 시스템을 만드는 게 답이에요.But all four failure roots come down to one thing: execution before design. The thinking was "a better prompt will fix it." But prompt optimization is a patch. The underlying problem is the absence of a system. The answer isn't getting better individually — it's building a system that produces above a consistent threshold no matter who uses it.

9 · 패턴 분석 3 — Rule 조합 전략9 · Pattern 3 — Rule combination strategy

케이스들을 보면서 하나 눈에 띄는 게 있었습니다. 하나의 Rule만 쓰는 경우는 없었어요. 항상 조합이었습니다. 복잡한 작업을 분해해야 할 때는 룰 넘버 나인, 텐, 포틴이 함께 왔어요. 반복 가능한 출력이 필요할 때는 룰 넘버 파이브, 식스, 서틴이 함께 작동했고요. 팀 단위 품질 관리엔 룰 넘버 피프틴과 식스틴이 함께 작동했습니다.Looking across the cases, one thing stood out: no single Rule was used alone. It was always a combination. Decomposing complex work brought Rule Numbers Nine, Ten, and Fourteen together. Repeatable output had Rule Numbers Five, Six, and Thirteen working together. Team quality control had Rule Numbers Fifteen and Sixteen working in tandem.

장기 프로젝트에서는 더 많은 Rules가 함께 작동했어요. 룰 넘버 투로 컨텍스트를 지키고, 룰 넘버 포틴으로 팀을 구성하고, 룰 넘버 피프틴으로 신뢰를 설계하고, 룰 넘버 식스틴으로 팀 거버넌스와 공유 체계를 만드는 식으로요. 이 표는 고정된 정답이 아니에요. 자기 상황에서 어떤 Rules가 함께 작동하는지를 찾는 출발점입니다. 조합을 찾는 능력 자체가 숙련의 증거예요.In long-running projects, more Rules worked together: Rule Number Two to protect context, Rule Number Fourteen to assemble the team, Rule Number Fifteen to design trust, and Rule Number Sixteen to build team governance and sharing systems. This table isn't a fixed answer — it's a starting point for finding which Rules work together in your own situation. The ability to find the right combination is itself a sign of mastery.

10 · 패턴 분석 4 — 상황별 Rule 선택10 · Pattern 4 — Choosing Rules by situation

어떤 Rule을 먼저 꺼낼지를 상황별로 정리해 봤습니다. 지금 컨텍스트가 흐려지고 있다면 가장 먼저 룰 넘버 투를 꺼내세요. 컨텍스트를 보호하는 방법을 점검하는 게 먼저입니다. 출력이 매번 다르고 형식이 통일되지 않는다면, 룰 넘버 파이브를 꺼내세요. 명령을 더 잘하는 게 아니라, 원하는 출력을 제약으로 먼저 설계하는 겁니다.Let me map out which Rule to reach for first by situation. If context is getting foggy right now, reach for Rule Number Two first — reviewing how you're protecting context is the priority. If output varies every time and format isn't consistent, reach for Rule Number Five. The answer isn't better commands — it's designing the desired output as a constraint first.

팀이 AI 결과를 믿지 못한다면 룰 넘버 피프틴입니다. 신뢰는 개인이 "더 잘 쓰면" 생기는 게 아니라, 시스템으로 설계해야 생깁니다. 그리고 같은 실수가 반복된다면 룰 넘버 식스틴. 개인 노하우가 팀 인프라로 전환되지 않은 겁니다. 실패 케이스를 기록하고 공유하는 거버넌스가 없으면 팀 평균은 절대 올라가지 않아요. 기억하세요. 이건 첫 번째로 꺼낼 Rule이에요. 반드시 다른 Rules와 조합해서 써야 합니다.If the team doesn't trust AI output, that's Rule Number Fifteen. Trust doesn't come from individuals "getting better at it" — it has to be designed into the system. And if the same mistakes keep repeating, that's Rule Number Sixteen. Individual know-how hasn't been converted into team infrastructure. Without governance for recording and sharing failure cases, the team average never rises. Remember: these are first Rules to reach for. You always need to combine them with other Rules.

11 · 실천 1 — 나만의 케이스 스터디 만들기11 · Practice 1 — Build your own case study

이제 실천으로 넘어가겠습니다. 오늘 본 네 가지 사례는 저의 케이스예요. 그런데 여러분한테 가장 유용한 케이스는 여러분 자신의 것입니다. 지금 당장 할 수 있는 걸 드리겠습니다. 최근에 AI와 함께 한 작업 중에서 가장 잘 됐던 것 하나를 골라보세요. 그리고 그걸 한 장으로 정리해 보세요. 문제가 무엇이었는지, 어떻게 접근했는지, 어떤 Rule이 작동했는지, 그리고 결과가 어땠는지.Now let's move to practice. The four cases we saw today are my cases. But the most useful case for you is your own. Here's something you can do right now: pick one thing from recent AI work that went really well. Then summarize it on one page — what was the problem, how did you approach it, which Rules worked, and what was the result.

그다음, 그게 재현 가능한지 점검해 보세요. "한 번 잘 됐다"는 경험은 운일 수 있어요. 다음에 같은 상황이 왔을 때 같은 접근법을 쓸 수 있어야 진짜 케이스가 됩니다. 그리고 팀이 있으면 공유하세요. 남의 케이스도 내 자산입니다. 팀이 케이스를 쌓아가면 시스템 자체가 배워 나갑니다.Then check whether it's reproducible. "It worked once" can be luck. It becomes a real case only when you can use the same approach the next time the same situation comes. And if you have a team, share it. Someone else's case is your asset too. When a team accumulates cases, the system itself learns.

12 · 실천 2 — Rule 활용 자가진단12 · Practice 2 — Self-diagnosis

자가진단을 한번 해볼게요. 지금 자신한테 가장 솔직하게 물어보세요. 컨텍스트가 자주 흐려집니까? 그렇다면 컨텍스트 관리 영역이 약한 겁니다. 형식 없이 출력을 받다가 나중에 합치지 못한 적이 있습니까? 그렇다면 프롬프트와 구조 설계 영역이에요. 혼자 몰아서 쓰다가 품질이 들쭉날쭉해진 적이 있습니까? 에이전트와 팀 설계 영역이 필요합니다.Let's do a self-assessment. Ask yourself as honestly as you can right now. Does your context get foggy often? Then context management is your weak area. Have you ever received output without a format and then couldn't combine it later? That's the prompt and structure design area. Have you ever piled everything on one and had quality go up and down? That's the agent and team design area.

검증 없이 AI 결과를 그냥 쓰다가 문제가 생긴 적이 있습니까? 그렇다면 신뢰와 평가 설계 영역이 부족한 겁니다. 중요한 건, 모든 걸 다 잘해야 한다고 생각하지 마세요. 약한 곳을 하나만 골라서 다음 주에 집중하는 것만으로도 충분합니다. 한 번에 다 바꾸려면 지쳐서 아무것도 못 바꿔요.Have you ever used AI output without verifying and run into a problem? Then trust and evaluation design is where you're thin. The important thing: don't think you have to do everything well. Picking just one weak area and focusing on it next week is enough. Trying to change everything at once leads to burnout and changing nothing.

13 · 실천 3 — 팀 공유 방법13 · Practice 3 — Sharing with your team

마지막 실천은 팀 공유입니다. 케이스를 나만 갖고 있으면, 내가 팀을 떠나는 순간 사라져요. 그리고 팀의 평균이 올라가지 않습니다. 반대로 케이스를 팀이 공유하면, 그 케이스는 공유 자산이 됩니다. 한 사람이 발견한 패턴을 팀 전체가 씁니다. 그러면 팀이 시간이 갈수록 더 좋아지는 시스템이 만들어져요.The final practice is team sharing. If you keep cases to yourself, they disappear the moment you leave the team. And the team average doesn't rise. On the flip side, when the team shares cases, those cases become shared assets. A pattern one person found gets used by the whole team. That creates a system where the team gets better over time.

거창하게 시작할 필요는 없어요. 최소한 한 달에 한 번, 내 케이스 하나를 팀에 공개해 보세요. 어떤 상황이었는지, 어떤 접근법이 통했는지, 그리고 다음엔 어떻게 할 것인지. 이것만으로도 팀의 집단 지식이 쌓입니다. 그리고 팀원의 케이스도 여러분의 자산이 됩니다. 이게 룰 넘버 식스틴, 개인 도구가 팀 인프라가 되는 가장 작은 첫 걸음이에요.You don't need to start big. At minimum, once a month, share one of your cases with the team — what the situation was, which approach worked, and what you'd do differently next time. Even this alone accumulates collective knowledge for the team. And your teammates' cases become your assets too. This is the smallest first step of Rule Number Sixteen: converting a personal tool into team infrastructure.

14 · 마무리 — 이론이 현장에서 증명될 때14 · Closing — when theory is proven in the field

오늘 배운 걸 한 문장으로 정리하겠습니다. 케이스는 문제, 접근법, Rule, 결과의 네 요소로 이뤄집니다. 그리고 그게 재현 가능할 때, 비로소 내 패턴이 됩니다. 이론은 원리를 알려줘요. 현장은 그 원리가 정말 작동하는지를 보여줍니다. 그리고 내 케이스는 그 원리를 내 상황에 맞게 구체화한 거예요. 이 세 단계가 모여야 진짜 실력이 됩니다.Let me summarize today in one sentence. A case is made of four elements: problem, approach, Rule, and result. And when it's reproducible, it becomes your pattern. Theory tells you the principle. The field shows whether that principle actually works. And your own case makes that principle concrete for your specific situation. All three stages together are what make real skill.

그리고 사실 오늘 가장 중요한 사례는 이 강의 자체였습니다. 이 하우 투 클로드 코스는 룰 넘버 포틴, 멀티에이전트로 만들어졌어요. 오케스트레이터와 일곱 개의 전문 팀이 스무 강을 만든 겁니다. 원리를 가르치는 강의가 그 원리로 만들어진 거예요. 다음 강, 스무 번째이자 마지막 강에서는 지금까지 배운 스무 개의 Rule을 하나의 지도로 완성합니다. 처음부터 끝까지의 여정을 한눈에 봅니다. 거기서 뵙겠습니다.And actually, the most important case today was this lesson itself. This How_to_claude course was built with Rule Number Fourteen — by multi-agent. An orchestrator and seven specialist teams made twenty lessons. The lesson teaching the principle was itself made by that principle. In the next lesson — the twentieth and final one — we'll complete all twenty Rules learned so far as one unified map. We'll see the whole journey from beginning to end at a glance. See you there.