개발자가 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.

Core systems and features (actionable / tutorial-style)

1. Automatic manual system (make AI actually read and follow rules)

• 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.

2. Working-memory / project-history system (solve AI’s short-term memory)

• 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.

3. Automatic quality inspection system (factory-style QA)

• 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.

4. Professional agents (specialized AI team members)

• 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.

Practical tips, pitfalls, and metrics

• 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.

Step-by-step condensed guide (to replicate)

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

Key benefits claimed

• Consistent, higher-quality outputs from AI
• Reduced rework and time spent fixing creative/incorrect interpretations
• Scalability: enabled a single developer to deliver a big project in six months
• Applicable across AI platforms (not limited to Claude Code)

Main speakers / sources

• 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).