Build a Production AI Agent in 6 Weeks
Production code from day one, reviewed line-by-line by senior engineers.
For intermediate Python developers ready to engineer AI apps, not just call APIs. You write production code. We read every line for architecture, naming, and decoupling.
Build "Expense AI Agent": a complete AI application with function calling, structured outputs, a Telegram bot, a web dashboard, 95%+ test coverage, and Docker deployment. The architecture patterns behind production AI systems, learned by building one.
Try ten free exercises first. A small sample of the patterns we cover early in the cohort — API calls, structured outputs, tool use, the provider Protocol, the repository pattern. Browser-based: no install, no API key, ~5 minutes each.
The exercises are a teaser. The cohort goes much further: six weeks of production architecture, three interfaces, Docker deploy, 150+ tests, and line-by-line PR review on every push.
How it works: Test-Driven Coaching
Most courses give you videos to watch. This one gives you tests to pass, and a senior engineer to review the code you wrote to pass them.
Each week, you receive a complete pytest test suite, all red. You write production code until they turn green. "Done" is objective: pytest exits with status code 0. But green tests are only the baseline.
- Step 1: RED. You receive a complete pytest suite, all failing.
- Step 2: Write. You write the production code, week by week.
- Step 3: GREEN. Tests pass.
pytestexits with status code 0. - Step 4: The Senior Review. Passing tests is the baseline. We then review your PR to ensure your solution is maintainable, decoupled, and production-ready: naming, service boundaries, and why you chose this pattern over another.
150+ tests across 6 weeks. Every pattern has a test that proves you've learned it. But the real product is the review. What happens between the lines: the invisible work of architecture, naming, and decoupling that separates production code from tutorial code.
This is how production teams work. You leave with the instinct.
Who is this for?
Intermediate Python developers who want to go beyond API demos and LLM wrappers. You'll learn how to architect AI applications that are testable, deployable, and maintainable, with the same engineering discipline you'd apply to any production system.
Time commitment: ~10 hours per week.
What you'll build
A full-stack AI agent, from data layer to deployment, with multiple interfaces and production-grade engineering.
Not a notebook demo. You ship a repository pattern, an LLM service layer with structured outputs, four working interfaces (CLI, Telegram, REST, Dashboard), 95%+ test coverage, and a Docker deployment.
Agent architecture
Repository pattern, service layers, Python Protocols for swappable LLM providers. Function calling and Pydantic structured outputs, not string parsing. Clean separation of concerns throughout.
Multi-interface delivery
CLI with Typer + Rich, a Telegram bot with human-in-the-loop confirmation, FastAPI REST API, and a Streamlit dashboard with analytics. One agent, three ways to interact with it.
Production-grade testing
150+ tests across 6 weeks. 95%+ coverage. Docker deployment, CI/CD pipelines, and documentation. You ship an app that's ready for users, not a notebook that's ready for a demo.
What you ship in 6 weeks
Six weeks of merged PRs, every one reviewed line-by-line by a senior engineer for architecture, naming, and decoupling. The artifact lives in your GitHub.
The end product
On the go: capture expenses by chat, with human-in-the-loop confirmation.
Back home: review and analyze in the Streamlit dashboard.
Program overview
What you build, week by week
Scaffolding
- Repository pattern for data access
- SQLModel entities & migrations
- StrEnum for categories & currencies
- In-memory + database repositories
- Test-driven from day one (26 tests)
LLM Integration
- Python Protocols for swappable providers
- Pydantic structured outputs
- OpenAI function calling / tools
- LLM client abstraction layer
- Type aliases for clean interfaces
Agent Tools & CLI
- Prompt engineering for classification
- Service layer orchestration
- CLI with Typer + Rich
- Database persistence layer
- Classification pipeline end-to-end
Telegram Bot
- Input preprocessing & validation
- Conversation state management
- Human-in-the-loop confirmation
- Inline keyboards & interactions
- Mobile-first AI interface
Web Interface
- FastAPI with dependency injection
- Pydantic request/response schemas
- Streamlit dashboard + Plotly charts
- REST API with OpenAPI docs
- Multi-client architecture
Deploy & Ship
- Docker multi-stage builds
- Docker Compose orchestration
- GitHub Actions CI/CD
- 95%+ test coverage
- Production-ready deployment
Tech stack: SQLModel, Pydantic, OpenAI function calling, Typer + Rich, FastAPI, Streamlit, Telegram bot API, Docker, GitHub Actions
What developers ship after coaching
We're currently beta-testing the curriculum with one developer, so no AI-cohort case studies on this page yet. The coaching system isn't new, though — Bob and Juanjo have been reviewing PRs and mentoring AI builds for years. Two recent examples of what developers they've coached have shipped:
Tim Gallati → working AI app in 6 weeks (with Juanjo)
"I learned the intricacies of developing RAG systems in 6 weeks(!) that would have otherwise taken 6 months – 1 year on my own. Juanjo's deep knowledge of Python development, AI applications, and infrastructure were mind blowing. […] You should work with Juanjo."
Tim Gallati · Senior Cybrarian @ Oracle · Founder, Quiet Links Library
Luca S. → AI-assisted POC shipped to production (with Bob)
"I was building a full-stack application mostly through AI-assisted coding and needed guidance to take it from proof of concept to production. Bob coached me through the parts I couldn't validate on my own: Django settings architecture, payment security, error handling patterns, query optimization. He reviewed my codebase thoroughly, explained why things mattered, and helped me build a concrete testing strategy. More than anything, his coaching gave me the confidence to actually ship."
Luca S. · Founder · Took a proof of concept to production SaaS
The coaching backbone behind both wins: 150+ developers coached since 2020 · 500+ exercises across Pybites Platform and Rust Platform · 22+ years industrial operations engineering (Repsol · ADNOC · Moeve) before AI. Same system, now applied to AI.
Book your 30-min call with Bob & Juanjo →
Code review that levels you up
Every week you push code, and your coaches review it. Not just for correctness, but for architecture.
- GitHub PR reviews: detailed feedback on patterns, naming, and structure
- Architecture guidance: repository pattern, service layers, dependency injection done right
- Testing rigor: not just "does it pass" but "does it test the right thing"
- Iterative improvement: multiple rounds push you toward clean, idiomatic Python
You finish with a GitHub history that shows engineering discipline, not tutorial copy-paste.
Career impact
Four things that transfer to every AI project after this
Most AI tutorials stop at "call the API." This cohort teaches you to build AI applications the way production teams do.
- Architecture patterns that transfer: Protocols, repository pattern, service layers, dependency injection. These aren't AI-specific; they're how senior engineers build software.
- Full-stack AI delivery: CLI, bot, API, dashboard. You can build the interface layer for any AI system, not just the LLM call.
- Testing AI applications: 150+ tests, 95%+ coverage on an AI app. Most portfolios have zero. This stands out.
- Deployment confidence: Docker, CI/CD, environment config. You ship to production, not just to a notebook.
You leave with a deployed app and the patterns to build the next one yourself.
Join the cohort
Six weeks, two coaches, a portfolio-ready project. What video courses can't give you: a human reading every PR you push.
€2,000 one-time · 6 weeks
- Detailed PR review on every push — architecture and design tradeoffs, not just whether tests pass
- Capped at 6 developers — the high-touch attention a typical bootcamp can't give you
- Weekly group call with both coaches
- Invite-only community for peers and accountability
- 6-week structured curriculum with agent architecture & high test coverage
Prefer 1:1 on your own project?
Some developers bring their own AI project — adapted to their business logic, not the cohort's expense agent. That's the 1:1 tier with Juanjo (the path Tim Gallati took for Quiet Links above). Ask about it on the call.
Your coaches
Juan José Expósito González, Python & AI Mentor and PhD Engineer. Guides developers from Python basics to advanced AI implementations. Expert in Python, machine learning, blockchain, and algorithmic trading. Passionate about transforming complex concepts into practical, clean architecture, testable and deployable solutions.
Bob Belderbos, Developer coach and builder with 11 years at Sun/Oracle and 6+ years running Python coaching programs. Co-founded Pybites and built Pybites Platform (400+ Python exercises). 100+ developers coached. Bob brings the architecture perspective: clean code, testable design, and bridging the gap between AI prototypes and production-ready applications.
Frequently asked questions
Do I need AI/ML experience? No prior AI experience needed. You should be comfortable with Python at intermediate level. We teach the AI patterns through the project.
What if I fall behind? Sessions are recorded. You have async support from Juanjo and Bob throughout the week.
Do I need an OpenAI API key? Yes, you'll use the OpenAI API for function calling and structured outputs. Cost is minimal (a few dollars for the full program).
How much time per week? ~10 hours including the live session, coding exercises, and building your app.
Will this help my portfolio? Yes. An AI agent with function calling, a Telegram bot, a web dashboard, Docker deployment, and 95%+ test coverage is a serious portfolio piece. Most AI projects on GitHub have none of that.
What community support is there? You get access to our invite-only community where you can ask questions, share progress, and connect with other developers.
Why not just follow YouTube tutorials? This is how tutorial hell starts. You watch someone build an AI app, you copy along, you feel productive, and you still can't tell if your architecture is wrong, your tests are testing the right thing, or your service layer is coupled in ways that will hurt you later. AI assistants make it worse: code that runs but nobody understands. Here, every line of code you push is read by a senior engineer who will tell you why a pattern is right or wrong. The code review is the product.
What's the return on €2,000? A deployed AI agent on your GitHub, the patterns to build the next one, and a code-review history that shows engineering discipline. The architecture skills transfer to every Python project after this, AI or not.
Ready to ship a production AI agent?
Tell us what you want to build with AI. We'll get on a call, talk through your goals, and figure out whether this cohort is the right fit.
Book your 30-min call with Bob & Juanjo →
In 6 weeks, a deployed AI agent. Not a tutorial. A product.