Zero to live, then keep it running and scaling.
A free, end-to-end guide to vibe coding production-grade software with AI, from a plain idea to live, monitored, scaling software, built with agents like Cursor and Claude Code. No signup, no paywall to start reading.
This is the community and companion repository for the book, not the book text itself. It exists for two things:
- Discussions and Q&A on the book and on every chapter. Ask questions, share what you built, and correct or extend a chapter, right where you read it.
- Companion materials you can install and use: an AI OS, agents, boilerplates, Claude Code skills, and worked examples. See Coming soon.
People who build software mostly by directing an AI agent (Cursor, Claude Code, and friends) and want to ship apps that are actually reliable, secure, and maintainable, not just demos that fall over in production. No CS degree assumed. If you can describe what you want and read what the agent gives back, this is for you.
AI can write the code. It cannot yet decide what to build, how to structure it, when it is wrong, or what "production-grade" means. This book teaches the professional lifecycle around the code, from a plain idea to live, monitored, scaling software, at a level a non-pro can follow. Full reasoning lives in the book itself.
The complete arc, from a plain idea to live, scaling software:
- Requirements: Turning an Idea Into a List
- MVP: Cutting Scope to the Core
- Components: The Pieces of an App
- Data Model: Mapping What You Store
- NFRs: The Requirements Nobody Says Out Loud
- Spec: Writing It All Down
- Stack: Choosing Your Tools
- Environment: Getting Your Machine Ready
- Version Control: Never Losing Work
- Secrets: Handling Keys and Config
- Agent: Meeting Your AI
- Rules: Setting the Ground Rules
- OS-First: Why the System Comes Before the Code
- Unification: One System for Everything
- Departments: Folders as an Org Chart
- Control Center: Your Command Hub
- Configuration: Standing Up Your Agents
- Scheduling: Putting Agents on a Clock
- Reporting: Commands and What Comes Back
- Modularity: A Foundation That Bends
- Structure: Where Everything Lives
- Coupling: Keeping Pieces Independent
- Layers: Drawing the Boundaries
- Conventions: Naming Things Consistently
- Handoff: Teaching Your AI the Architecture
- Scaffolding: Blank Screen to Running App
- Direction: Steering Your Agent
- Increments: Working in Small Steps
- Code Review: Checking the Agent's Work
- Stack Traces: Reading What Broke
- Loops: When Your Agent Goes in Circles
- Bisecting: Finding the Change That Broke It
- Verification: Is It Actually Fixed?
- Rollback: Reverting Safely
- Escalation: Getting Unstuck
- Interface: Designing How It Looks and Feels
- Accounts: Data, Users, and Payments
- Validation: Trusting No Input
- Reliability: Handling Failure Gracefully
- Testing: QA Before Users Find It
- Security: Locking It Down
- Performance: Speed and Accessibility
- Deployment: Going to Production
- Environments: Dev, Staging, Production
- IaC: Infrastructure as Code
- CI/CD: Automating the Deploy
- Releases: Safe Rollouts and Rollbacks
- Observability: Seeing Inside Your App
- Alerting: Monitoring and Getting Paged
- Backups: Disaster Recovery
- Incidents: Maintenance When Things Break
- Cost: Watching the Bill
- Automation: Letting the System Run Itself
- Bottlenecks: Finding the Limits
- Caching: Easing the Database
- Horizontal Scaling: Adding Capacity
- Capacity Planning: Staying Ahead of Growth
- Optimization: The Improvement Loop
- Expertise: When to Call a Pro
Companion materials you'll be able to install and use, landing here as their chapters go live:
- AI OS: a ready-to-run operating system for your agents, the control center, departments, scheduling, and reports the book builds.
- Agents: preconfigured Claude Code agents you drop in and run.
- Boilerplates and starters: production-shaped project scaffolds with the modular structure and agent house-rules already wired.
- Claude Code skills: reusable agent workflows the book teaches, drop into
.claude/skills/and go. - Examples: worked, runnable code and artifacts from the chapters.
Nothing shipped yet, this is where it will land. Watch or star the repo to catch it.
Every chapter page has its own comment thread. Comment right from the page, or open a discussion here. Be kind, stay on topic, and search before posting.
Spotted an error, an outdated command, or a gap? Open a discussion or a pull request. Content fixes flow back into the book; skills, starters, and examples live and evolve here.
Use the materials here to build anything you want, including commercial products. Just don't resell or redistribute the materials themselves as a standalone product. The book's text is not in this repo and is all rights reserved. See LICENSE.
Written by Mahmoud Zalt · zalt.me