Michael Kim (김완기)

R&D Lab Director · 18+ years full-stack
From firmware to cloud

4 minute read

##

  • Project: AI-powered customer support system (FastAPI + Next.js + PostgreSQL + Electron)
  • Size: 17,450 lines of code, 87 commits, 11 design documents
  • Development time: 2 days
  • Conclusion: Work that would take three juniors 2–3 weeks, finished in 2 days with Claude Code

1. Project overview

MailBean customer support system

An AI-powered customer support platform for a B2B coffee machine rental/sales company.

Tech stack

Area Technology
Backend FastAPI, Python 3.11, SQLAlchemy, PostgreSQL
Frontend Next.js 14, TypeScript, Tailwind CSS
Desktop Electron 28 (cross-platform builds)
Infra Docker Compose, Redis, WebSocket
AI OpenAI GPT-4 (automated customer inquiry handling)

2. Features built

Backend API (19 modules)

  • Authentication (JWT, role-based access control)
  • AI chat over WebSocket (live customer support)
  • Ticket management (creation/assignment/status)
  • Dashboard statistics API
  • Contract/quote/invoice management
  • Production scheduling
  • Engineer task assignment
  • Team lead notification system
  • File upload (images/documents)

Frontend pages (10)

  • Login/auth
  • Dashboard (live statistics)
  • Ticket list/detail
  • Customer management
  • Contract/quote management
  • Invoice management
  • Production schedule
  • Engineer tasks
  • Admin settings

Electron desktop app

  • Chat client for customers
  • Windows/macOS/Linux cross-builds
  • Hardened security (context isolation, preload script)

3. Code size in detail

    Total lines of code: 17,450

    Backend (Python)
    ├── Files: 52
    ├── Lines: 9,825
    └── API endpoints: 50+

    Frontend (TypeScript)
    ├── Files: 21
    ├── Lines: 6,217
    └── Components: 30+

    Electron Client
    ├── Files: 5
    ├── Lines: 1,400
    └── Build artifacts: 4 (DMG, EXE, etc.)

    Design documents: 11
    Docker configuration: 4 services

4. Estimated schedule for three junior developers

Assumptions

  • Junior developers: 1–2 years of experience
  • Full-time (8 hours/day)
  • Basic familiarity with the stack

Estimated schedule

Phase Work Estimate Owner
Week 1 Environment setup, DB schema design 3 days Everyone
Week 1 Authentication system 2 days Backend
Week 1 Basic UI layout 2 days Frontend
Week 2 Ticket CRUD API 3 days Backend
Week 2 Ticket list/detail pages 3 days Frontend
Week 2 WebSocket real-time communication 2 days Backend
Week 3 AI chat integration 3 days Backend
Week 3 Dashboard statistics 2 days Frontend
Week 3 Remaining pages 3 days Frontend
Week 4 Electron app 3 days Separate
Week 4 Testing and bug fixes 3 days Everyone
Week 4 Deployment configuration 2 days Everyone

Total estimate: 3–4 weeks (15–20 business days)

Additional considerations

  • Code review time
  • Communication overhead
  • Delays in technical decision-making
  • Merge conflict resolution
  • Documentation work

5. The actual development process with Claude Code

Day 1 (8 hours)

    09:00 - Project structure design, Docker environment setup
    10:00 - DB schema design and model generation
    11:00 - Authentication (JWT, role-based)
    12:00 - Lunch
    13:00 - Ticket API and WebSocket implementation
    15:00 - AI chat integration (GPT-4)
    17:00 - Frontend base layout
    18:00 - Login, dashboard, ticket pages

Day 2 (8 hours)

    09:00 - Remaining pages (contracts, invoices, production)
    11:00 - Real-time notification system
    13:00 - Electron app
    15:00 - Cross-platform build configuration
    16:00 - Deployment configuration (Docker Compose)
    17:00 - Testing and bug fixes

Total time: 2 days (16 hours)

6. Efficiency comparison

Quantitative

Metric 3 juniors Claude Code + 1 person
Total duration 15–20 days 2 days
Total person-hours 360–480 hours 16 hours
Lines/day ~1,000 ~8,700
Bug rate Medium Low
Documentation Separate effort required Generated alongside development
Consistency Varies by individual Consistent code style

Cost comparison (assuming a junior salary of ₩40M/year)

    3 juniors × 3 weeks
    = 3 × (₩40,000,000 ÷ 52 weeks) × 3 weeks
    = about ₩6.9M in labor

    Claude Code
    = API cost of roughly $50–100 (₩50,000–100,000)
    + 1 senior × 2 days (about ₩300,000)
    = about ₩350,000–400,000

Cost reduction: about 95%

7. Claude Code’s strengths

1. Context retention

  • Understands the whole codebase and keeps it consistent
  • Remembers and applies earlier decisions

2. Fast prototyping

  • Design → implementation with no gap
  • Minimal feedback loop

3. Fluency across stacks

  • Python, TypeScript, SQL, Docker simultaneously
  • Applies best practices in each area

4. Automated documentation

  • Design documents generated alongside code
  • API documentation generated automatically

5. Fewer mistakes

  • Type errors and security vulnerabilities prevented up front
  • Consistent error handling

8. Limitations and caveats

Where Claude Code falls short

  1. Creative UX design: user interviews and UX research need humans
  2. Understanding business logic: domain expertise has to come from a human
  3. Latest libraries: changes after the training data cutoff
  4. Infrastructure operations: actual server operation and monitoring are separate

The human developer’s role

  • Defining requirements and setting priorities
  • Architectural decisions
  • Code review and quality verification
  • Gathering user feedback

9. Conclusion

Who wins?

Both.

Claude Code doesn’t replace junior developers; it’s a tool that makes a senior developer more than 10× more productive.

  • Fast MVP development
  • Prototyping
  • Repetitive CRUD work
  • Documentation
  • Code refactoring

Where humans should focus

  • User experience design
  • Business strategy
  • Team collaboration and communication
  • Creative problem-solving

Appendix: project structure

    mailbean-customer-support/
    ├── backend/
    │   ├── app/
    │   │   ├── api/          # 19 API modules
    │   │   ├── models/       # SQLAlchemy models
    │   │   ├── services/     # business logic
    │   │   └── main.py
    │   ├── Dockerfile
    │   └── requirements.txt
    ├── frontend/
    │   ├── app/              # Next.js 14 App Router
    │   ├── components/       # React components
    │   └── Dockerfile
    ├── electron-test-client/
    │   ├── main.js
    │   ├── preload.js
    │   ├── renderer.js
    │   └── dist/             # build artifacts
    ├── docs/
    │   └── 02-design/        # 11 design documents
    └── docker-compose.yml

Written: January 19, 2026 Author: Michael Kim Project: MailBean Customer Support System Tool: Claude Code (Anthropic)

Updated: