Build a Production AI Agent in 6 Weeks
API calls are table stakes. Architecture is the differentiator.
For intermediate Python developers ready to engineer AI apps, not just call APIs. This isn't ML or data science; it's engineering applications that use models. You write production code; two senior engineers review it deeply for architecture, naming, and decoupling.
Coached by Juanjo & Bob · meet your coaches ↓
In six weeks you build and deploy Expense AI Agent: function calling, structured outputs, a Telegram bot, a web dashboard, 95%+ test coverage, and Docker. Not a notebook demo. A product you ship to production, and the architectural instinct to build the next one yourself.
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.
Get sharper at building with AI, every two weeks
A biweekly email on working with AI and building agentic systems in Python: the architecture, testing, and prompting patterns we use to ship real agents, the same ones behind the cohort. One focused read, no fluff. Plus first word when the next seats open.
No spam. Unsubscribe anytime.
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.
Already comfortable building agents? Cohort 2: Retrieval Engineering → The advanced track. You build askrepo: a coding assistant that indexes a real repository, answers with provenance, and proposes patches that pass the target repo's own tests.How the cohort runs
Live, or on your schedule
A weekly live call with both coaches: Bob on architecture, Juanjo on AI and infra. Every session is recorded, so a week you can't attend never blocks you, and async support runs all week in between.
Two senior engineers on your code
Not office hours or generic Q&A. Every PR you push gets a line-by-line review from two senior coaches: naming, service boundaries, and why one pattern over another.
A small cohort, capped at six
Six developers per cohort, so the review stays deep and your questions get answered. An invite-only community for peers and accountability, during the six weeks and after.
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, three working interfaces (CLI, Telegram, Web: REST API + 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
A web dashboard to classify, review, and analyze: the polished front door to the agent, with charts, category breakdowns, and a REST API behind it.
And on the go: capture expenses by chat, with human-in-the-loop confirmation. The same agent, a second interface.
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
Book your 30-min call with Bob & Juanjo →
Starts October 26, 2026. Already convinced? Register directly →
What developers say about the coaching
"Agentic development has become a popular topic lately and the noise can overshadow its essence. Through the 6 weeks of the program we built a production-ready Expense AI Agent, and Bob and Juanjo guided us through understanding and applying the patterns used by seniors in the industry." - Daniele E.
"The project was great. Even better was having experienced coaches walk me through end-to-end. Expert feedback pushing my edge and helping me get to the next level. Someone holding me accountable all the way through delivery." - James S.
"I learned stuff about pytest, I learned stuff about mocking, and I learned stuff about my own code. I just ended up thinking about things in a different way. It's different having done it than even reading about it." - Jeff Haemer, writing software since the early 1980s. He shipped an agent with three interfaces (web, CLI, Telegram) and ~250 tests at 100% coverage.
The coaching backbone: 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 →
Starts October 26, 2026. Already convinced? Register directly →
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.
Want to try the teaching style first? Ten free browser-based exercises — the patterns from week 1–2. No install, no API key, ~5 minutes each.
Join the cohort
Six weeks. Two senior coaches. A deployed AI agent on your GitHub, and the architectural instinct to build the next one without us. Here's everything you get:
€2,000 one-time · 6 weeks · capped at 6 developers
- Line-by-line PR review on every push. Architecture, naming, and design tradeoffs, not just whether tests pass. This is the product, not a bonus. "It is not a very common choice to review code as deeply as you do."
- 150+ tests, pre-written and all red. Tests are the assignment; your code is the answer. "Done" is objective (
pytestexits 0), but green is only the baseline. - A full-stack agent you deploy. CLI, Telegram bot with human-in-the-loop, FastAPI + Streamlit dashboard, Docker, CI/CD. Three interfaces, one agent, shipped.
- Weekly live call with both coaches. Bob on architecture, Juanjo on AI & infra, plus async support all week.
- Invite-only community. Peers and accountability, during the six weeks and after.
- The patterns that transfer to every project after. Protocols, repository pattern, service layers, dependency injection, human-in-the-loop. How senior teams build, AI or not.
Bonus — Week 7: Agentic patterns. A seventh week beyond the core six: build your own tool-calling loop, stand up an MCP server, and wire the full agent loop. The frontier patterns, included.
What it costs everywhere else
- An AI bootcamp: $10–15k, generic curriculum, and no one reads the code you actually write.
- Hiring a senior to review your AI app: $150+/hour. Six weeks of weekly, line-by-line review runs into five figures.
- YouTube plus an AI assistant: free, and you end up with code that runs but nobody understands. That's where tutorial hell starts.
You get the expensive part, a senior engineer's deep code review, for €2,000, once.
Our guarantee
Push a PR every week and do the work. If you haven't shipped a deployed AI agent by the end of week 6, we keep coaching you — free — until you do. The only way this fails is if you don't write the code. And writing the code is the entire point.
Get sharper at building with AI, every two weeks
A biweekly email on working with AI and building agentic systems in Python: the architecture, testing, and prompting patterns we use to ship real agents, the same ones behind the cohort. One focused read, no fluff. Plus first word when the next seats open.
No spam. Unsubscribe anytime.
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 (whose 1:1 clients have shipped apps like Quiet Links, a RAG system over 200+ academic papers). 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, the code you push gets a deep review from 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 →
Starts October 26, 2026. Already convinced? Register directly →
In 6 weeks, a deployed AI agent. Not a tutorial. A product.
What's next: Cohort 2 — Retrieval Engineering
Cohort 1 teaches you to build an agent. Cohort 2 goes deeper into the layer where agents break: retrieval. Over 8 to 10 weeks you build askrepo, a coding assistant that indexes a real repository, answers with provenance, and proposes patches that pass the target repo's tests.
See the Retrieval Engineering cohort →
Get sharper at building with AI, every two weeks
A biweekly email on working with AI and building agentic systems in Python: the architecture, testing, and prompting patterns we use to ship real agents, the same ones behind the cohort. One focused read, no fluff. Plus first word when the next seats open.
No spam. Unsubscribe anytime.
