Summary of "개발자가 AI 길들이는 데 6개월 걸린 이유 (시행착오 전부 공개)"

What the video covers (high-level)

A developer rebuilt a large internal program alone in six months by orchestrating AI tools with structured systems rather than simply “using” the models.
Central idea:

AI works best when you create a process/harness around it — manuals, memory, inspection, and specialized agents — instead of leaving it unsupervised.

Uses Claude Code’s “Skill” concept: detailed rules for frontend, backend, DB handling, error patterns, security, etc.
Problem: AI ignored long manuals. Solution:
- Create two automated “starters”:
  - Pre-start notifier: analyzes user instructions and forces the AI to open the relevant manual chapter before starting.
  - Post-completion checker: inspects finished work and prompts for missing checks (error handling, security).
- Trigger manuals when all four conditions match:
  1. Keywords in the instruction (e.g., “backend”, “API”)
  2. Phrases indicating feature creation (e.g., “add feature”)
  3. File location (working in a specific folder)
  4. File contents (matching patterns)
- Split large manuals into a brief table of contents plus per-topic chapters to reduce context usage and improve relevance.
Results claimed: consistent output quality, faster edits, and 40–60% lower resource consumption versus loading huge manuals.

Always create and store three documents per project:
1. Plan — architecture blueprint / what to build
2. Context notes — why decisions were made, references
3. Checklist — task tracking: done / todo
Workflow tips:
- Let AI draft the plan, but carefully review and approve it yourself.
- Save the approved plan and start a fresh AI session that reads the saved documents before working.
- Stop the AI once the plan is approved; only resume with the saved docs loaded.
- Break work into small chunks (one or two tasks at a time) and update the checklist after each chunk to prevent the AI from “forgetting” decisions.

Modification recording device: automatically log each file change (who/when/what).
Post-completion inspection device: run tests after the AI finishes an answer — check recorded modifications for errors.
- If minor errors: present them to the AI for auto-fix.
- If many errors: flag for human/professional repair.
Self-check reminders: automated prompts after tasks asking the AI to confirm error handling, risky parts, etc.
Claimed outcome: almost zero escaped bugs because the inspector catches issues immediately.

Split responsibilities into role-based agents: planning, testing, QA, code review, etc.
Require detailed reports from agents — what they changed, why, and what they discovered — to avoid “I did it” one-line responses.
Use peer code reviews among AI agents to find missing parts, weaknesses, and consistency issues.

Don’t make one giant manual; split it into a TOC + short chapter files.
Trigger relevant manuals automatically instead of asking the AI to “remember” them.
Stop the AI at plan-approval, save docs, and start a fresh session that loads those docs.
Give small, discrete tasks and update the checklist frequently.
Run inspections after completion, not continuously during partial edits.
Claimed gains:
- 10x return on two days’ setup work
- 40–60% lower resource usage
- Far fewer AI “wanders”
- Enabled a single developer to rebuild a program ~3–4x the original size in six months
Tools referenced: Claude Code (Skills/review features) and mentions of other AI models (ChatGPT / GPT / Claude / Gemini / others). Some subtitle names may be auto-generated or mistranscribed.

Write concise modular manuals (TOC + chapters) and upload as “skills.”
Build pre-start and post-completion notifiers that automatically attach the right manuals based on keywords, file locations, patterns, or task phrases.
Use a three-document memory system: Plan → Context notes → Checklist. Let AI draft, then human review & save.
Pause after plan approval; start a new session that reads saved docs before any work.
Give AI only one- or two-task work units; update checklist after each.
Log all file modifications; run a post-completion automated test suite and self-check prompts; auto-fix minor errors, escalate major ones.
Use role-specialized AI agents and require written reports; include agent-to-agent code reviews.

Video narrator: an 8-year developer who rebuilt the program and explains the systems and workflow.
Primary source: a developer’s detailed Reddit post describing the six-month system-build (the video credits this Reddit post).
AI products mentioned: Claude Code (Skills and review features), and references to other large language models (ChatGPT/GPT, Claude, Gemini/others).