Episode 3. Practical Agentic Coding Guide for Junior Developers

# 1. Check Claude Code installation
claude --version

# 2. Enable Agent Teams
# Add to ~/.claude/settings.json
{
  "agentTeams": {
    "enabled": true,
    "mode": "in-process",
    "teamSize": 3
  }
}

# 3. Select Opus 4.6
claude --model opus-4-6

# New project directory
mkdir todo-app
cd todo-app

# Run Claude Code
claude

> I want to create a simple TODO app.
> Features: add, delete, mark complete
> Tech: React + TypeScript + Vite

> Analyze the entire codebase and suggest refactoring.
> Summarize the structure and improvement points of this project.

# Request task from Team Lead
> I need to implement this REST API.
> Need /users, /posts, /comments endpoints.
> Process in parallel using Agent Teams.

# Team Lead automatically distributes work
# Teammate 1: /users
# Teammate 2: /posts
# Teammate 3: /comments

# 1. Describe overall requirements
> I need to develop a blog backend API.
> - User authentication (JWT)
> - Post CRUD
> - Comment system
> - Tags and search
> - Tech stack: Node.js + Express + PostgreSQL + Prisma

# 2. Design overall architecture with Opus 4.6
> Design the overall project structure.
> Include DB schema, API routes, middleware.

# 3. Parallel development with Agent Teams
> Develop each feature in parallel using Agent Teams.

# Good start
> Create a simple calculator app.

# Too complex start (not recommended)
> Create a large-scale e-commerce platform with microservices architecture.

# Bad question
> Write code.

# Good question
> I want to create a TODO app with React and TypeScript.
> Features needed: add, delete, mark complete.
> Start with Vite and design the component structure.

> Explain how this code works.
> Why did you implement it this way?
> Is there another way?

> Also write test code for this feature.
> Both unit tests and integration tests please.

# 1. Organize requirements
> [Project description]

# 2. Decide tech stack
> Recommend a tech stack for these requirements.
> Compare pros and cons.

# 3. Design project structure
> Design the project structure.
> Include folder structure and file organization.

# 4. Generate initial code
> Generate the basic code.
> Config files, basic components, etc.

# 5. Develop with Agent Teams
> Now develop each feature in parallel using Agent Teams.

# 1. Analyze entire codebase
> Analyze the structure of this project.
> Summarize key files and dependencies.

# 2. Identify where to add feature
> Where should this new feature be added?
> How should it integrate with existing code?

# 3. Implement
> Implement this feature.
> Following the existing style.

# 4. Test
> Also add tests for this feature.

# 1. Reproduce bug
> Analyze why this bug occurs.
> [Error log]

# 2. Identify root cause
> What's the root cause?
> What needs to be fixed?

# 3. Suggest fix methods
> Suggest multiple fix approaches.
> Compare pros and cons of each.

# 4. Fix and test
> Fix it this way.
> Also add regression tests.

# Week 1: Simple code generation
> Write this function.

# Week 2: File-level work
> Refactor this file.

# Week 3: Feature-level work
> Implement this feature.

# Week 4: Agent Teams usage
> Develop this project using Agent Teams.

# Always ask these questions
> Are there any security issues with this code?
> How can I optimize performance?
> Are the tests sufficient?

> Why did you implement it this way?
> What's the name of this pattern?
> Is there a better way?
> Recommend documentation that explains this.

# Bad example
Relying entirely on AI without understanding anything

# Good example
Understanding and verifying what AI writes

# Bad example
Deploying AI code as-is

# Good example
Testing, reviewing, and verifying before deployment

# Bad example
> Fix the bug.

# Good example
> I'm getting a 500 error when users log in.
> Here's the error log, and the related code is in this file.