# Bob Belderbos — Engineering Coaching

> I help developers move beyond working code to the engineering judgment that directs it. Intensive 1:1 and cohort coaching in Python, Rust, and AI. AI is an accelerator, not a compass.

Bob Belderbos is a developer, coach, and builder based in Spain. 10+ years at Sun/Oracle building support and developer tooling, coaching developers since 2020. Co-founded Pybites and built its two coding platforms (500+ exercises, 50,000+ sign-ups). More than 150 developers coached, 1,000+ pull requests reviewed.

## Coaching

- [Coaching Overview](https://belderbos.dev/coaching/): 6-week project-based cohorts and custom 1:1 coaching in Python, Rust, and AI
- [Agentic AI Cohort](https://belderbos.dev/coaching/ai/): Build an AI-powered agent app — function calling, Telegram bot, Streamlit dashboard, Docker
- [Rust Cohort](https://belderbos.dev/coaching/rust/): Build a JSON parser in Rust from scratch — enums, ownership, borrowing, error handling, FFI, PyO3
- [Python 1:1](https://belderbos.dev/coaching/python/): Build a full-stack Python app — Snippet Manager (SQLModel, FastAPI, Typer) or a Django CRM SaaS (Django, HTMX, Stripe), deployed

## Blog

- [Database-Driven RBAC with FastAPI and Azure Entra ID](https://belderbos.dev/blog/database-driven-rbac-fastapi-azure-entra/): Wire Azure Entra ID roles into FastAPI, then keep the endpoint-to-role policy in the database so an admin can re-point access without a redeploy.
- [5 design patterns used in my new habit tracker app](https://belderbos.dev/blog/python-patterns-django-habit-tracker/): The best logic in a Django app is the code that never touches the ORM. Five small Python and design patterns from a habit tracker that keeps it decoupled.
- [Why does Alembic need an import you never use?](https://belderbos.dev/blog/what-table-true-does-sqlmodel/): That unused models import in env.py is a SQLModel metaclass side effect. The real call path from table=True down to metadata.tables in the source.
- [Unsubscribe links without a login: Django signing](https://belderbos.dev/blog/unsubscribe-without-login-django-signing/): How to build an email unsubscribe link that needs no login and no database token, using django.core.signing, and where the pattern gets dangerous.
- [Guardrails Protect Your Codebase. What Protects Your Judgment?](https://belderbos.dev/blog/ai-skill-atrophy-keep-the-friction/): AI coding erodes two different things: your skills and your code. Guardrails protect the code. Only re-deriving the hard decisions keeps your judgment sharp.
- [Learning New Skills in the AI Era (vBrownBag)](https://belderbos.dev/blog/vbrownbag-learning-skills-ai-era/): I joined the vBrownBag podcast to talk about learning new languages and skills when AI can write the code before you finish the thought.
- [Rust, AI, and the Developer Mindset (Develpreneur Podcast)](https://belderbos.dev/blog/develpreneur-podcast-rust-ai/): I joined the Develpreneur podcast with Jim Hodapp to talk about the Rust developer mindset and why the compiler is a great guardrail for AI-generated code.
- [Judgment: The Skill AI Can't Give You](https://belderbos.dev/blog/thinking-matters-more-than-ever-ai-age/): AI accelerates execution but not understanding. The developers who thrive won't be the fastest prompters. They'll be the ones who never stopped thinking.
- [One Core, Two Interfaces, No Rewrites](https://belderbos.dev/blog/two-interfaces-one-core/): The same pure functions back both a CLI and a FastAPI web app. Keep the core functional, cache the matrix, pre-warm on startup, no logic duplicated.
- [Ask the Canon: Semantic Search Without a Vector Database](https://belderbos.dev/blog/semantic-search-without-a-vector-database/): Running a semantic search over 100 classics on a droplet with embeddings, NumPy, and np.argsort. No Pinecone, no API calls at query time. Starting simple.
- [There Is No Magic: An AI Agent in 60 Lines of Python](https://belderbos.dev/blog/build-minimal-ai-agent-python/): An agent is a small amount of plumbing around a model you already understand. The whole anatomy in 60 lines of Python: model, instructions, memory, tools, loop.
- [Python Is Not Enough: Why Pythonistas Love Rust (Podcast)](https://belderbos.dev/blog/complexity-dot-fm-podcast/): I joined complexity.fm to talk about why Pythonistas are picking up Rust, what AI really does to how we learn, and why vibe coding is a myth.
- [AI Is an Accelerator, Not a Compass](https://belderbos.dev/blog/ai-accelerator-needs-direction/): AI makes you faster, but speed without direction produces three-day mistakes and dark code. Why fundamentals matter even more in 2026.
- [From Python to Rust: Master Iterators by Rebuilding 10 Unix Tools](https://belderbos.dev/blog/learn-rust-building-unix-tools/): Rebuild wc, grep, sort and sed in Rust, each exercise turning a Python idiom you know (loops, comprehensions, len) into the iterator chain you don't yet.
- [Profile First: A 10x Faster Django Test Suite](https://belderbos.dev/blog/profile-django-test-suite-10x-faster/): My Django test suite took 30 seconds. cProfile showed 83% of it was one function: password hashing. Here's how I found the bottleneck and the five-line fix.
- [End-to-End Testing Every Rust Exercise with Playwright](https://belderbos.dev/blog/playwright-e2e-testing-71-exercises/): How I use Playwright and pytest to end-to-end test every exercise on my Rust learning platform. Patterns that scale.
- [When to use classmethod, staticmethod, or instance method in Python](https://belderbos.dev/blog/classmethod-vs-staticmethod-vs-instance-method-python/): A simple decision rule for when to use a classmethod, a staticmethod, or a plain instance method in Python.
- [Building an AI Agent in 6 Weeks (and Finally Understanding How They Work)](https://belderbos.dev/blog/jeff-haemer-agentic-ai-cohort/): Jeff had decades in software but mediocre Python and no map of AI. Six weeks later: an agent with three interfaces, ~250 tests, and a real mental model.
- [Why Rust does not need OOP](https://belderbos.dev/blog/why-rust-does-not-need-oop/): Rust has no classes and no inheritance, yet it keeps the good parts of OOP. Five ways structs, traits, and ownership replace the class hierarchy.
- [AI Doesn't Change What Software Engineering Is](https://belderbos.dev/blog/ai-doesnt-change-what-software-engineering-is/): Kelsey Hightower's take on AI is the most grounded I've heard: it's a tool, and software engineering was always decision-making, not typing.
- [How to Update Multiple Page Elements from One htmx Request](https://belderbos.dev/blog/htmx-hx-swap-oob-django/): One htmx response, two updated elements. How I use hx-swap-oob to refresh a Django dropdown after a form submit, no page reload, no extra JavaScript.
- [\"Rust Is for People Who Want to Be Punished.\" Now Jochen Trusts It More Than Python.](https://belderbos.dev/blog/jochen-rust-cohort-beat-cpython/): Jochen thought Rust was self-punishment for the pros. Three months later, his hand-rolled JSON parser ran up to 3.5x faster than CPython.
- [How to Tell if Your Python Mock Is Actually Working](https://belderbos.dev/blog/python-mock-patch-verify-interception/): A test that passes because the real API returned an error is not a passing test. Here's how to verify your mock is intercepting, and fix it when it isn't.
- [Build the Simplest Thing That Works](https://belderbos.dev/blog/build-the-simplest-thing-that-works/): How constraints like 'no database' and 'two dependencies' led to a CLI CRM that fits in my head. A case for building small.
- [AI Human-in-the-loop: News Digest Triage Telegram Bot](https://belderbos.dev/blog/human-in-the-loop-telegram-bot-python/): A trend digest tells you what to read. This Telegram bot lets you tag and file each story with one tap; the human-in-the-loop pattern in less than 200 lines of Python.
- [The control layer is the product, not the model](https://belderbos.dev/blog/control-layer-is-the-product/): Gary Bernhardt called out the LLM fixation. The real work is the control layer above the model. Four patterns that make production AI reliable.
- [Learning a New Programming Language Is More Important Now, Not Less](https://belderbos.dev/blog/josh-rust-cohort-beat-cpython-json/): Everyone says AI agents make learning new languages obsolete. Josh spent six weeks learning Rust and built a JSON parser that beats CPython's C stdlib. Here's why developers who still learn languages will have the edge.
- [Two Python Scoping Bugs: A Lesson in Object Lifetimes](https://belderbos.dev/blog/two-scoping-bugs-object-lifetimes/): Two Python bugs with opposite symptoms but the same root cause: picking the wrong scope for a stateful object.
- [From Python Script to Production: A Django Coaching Case Study](https://belderbos.dev/blog/daniele-django-movie-anime-discovery/): Career changer, new to Django, built and shipped a movie and anime discovery platform in 6 weeks of 1:1 Python coaching.
- [Mind Map Your App Before You Write a Line of Code](https://belderbos.dev/blog/mind-map-software-project-scope/): Before scoping a project or writing code, spend 30-60 minutes building a mind map. This is the exercise I use with coaching students.
- [A 500 That Survived Ten Successful Deploys](https://belderbos.dev/blog/500-survived-ten-successful-deploys/): Page 500, clean local build, green CI. Tracing stale Cloudflare Pages state back ten releases and the lesson about silent failures.
- [What production AI agents actually require](https://belderbos.dev/blog/production-ai-agents-real-workflows/): Chatting is easy. Executing real business logic with audit trails, approvals, and rollback is where most AI agents break. Here is what to build.
- [How to Keep Your Developer Instincts When AI Writes the Code](https://belderbos.dev/blog/dont-delegate-the-friction/): AI agents will write your code if you let them. Here's the deliberate practice routine I use to stay technical when AI increasingly writes code for me.
- [10 Days of Rust for Python Developers: A Recap](https://belderbos.dev/blog/10-days-rust-python-developers-recap/): A day-by-day walkthrough of a 10-day beginner Rust challenge for Python developers. Real solution code and one idea per day that changes how you read Python.
- [Learn agentic AI in Python with 10 small exercises](https://belderbos.dev/blog/learn-agentic-ai-python-10-step-journey/): The path from a 3-line Claude call to a working agent loop. 10 patterns, one arc, runnable in your browser. No framework needed to understand what's actually happening.
- [Coding exercises that run in the browser with Pyodide](https://belderbos.dev/blog/python-exercises-browser-pyodide/): How I shipped 10 Python exercises with Anthropic SDK patterns on a static Cloudflare site. No backend, no API key, no install. Pyodide does the work.
- [A Race Condition Rust Wouldn't Have Let Me Write](https://belderbos.dev/blog/race-condition-rust-wouldnt-let-me-write/): A Python agent's module globals leaked user data between threads. The contextvars fix, plus what Rust's borrow checker would have prevented.
- [Build a daily AI digest in 200 lines of Python (no framework)](https://belderbos.dev/blog/python-ai-trend-digest-asyncio-protocol/): One Python script combines asyncio.gather, a Protocol for LLM swap, and StrEnum dispatch to fetch and rank AI news every morning.
- [The Rust Compiler as an AI Coding Agent Guardrail](https://belderbos.dev/blog/rust-compiler-ai-agent-guardrail/): Jim Hodapp and I talk about why Rust's strict compiler makes AI coding agents more reliable, and what Python developers gain from learning it.
- [Event Sourcing in Python: Get More Insights Into Your Data](https://belderbos.dev/blog/event-sourcing-python-store-events-not-state/): Event sourcing stores every change as an immutable event instead of overwriting state. Here is why that shift changes what questions your data can answer.
- [Python to Rust: A JSON Parser in 6 Weeks](https://belderbos.dev/blog/vikas-rust-cohort-ownership-pyo3/): What a senior Python engineer learned building a JSON parser from scratch in Rust.
- [Build the data layer before you touch the LLM](https://belderbos.dev/blog/build-data-layer-before-llm/): Most AI tutorials start with the API call. This one starts with a data model. Here's why, and what a proper data layer buys you in a production AI app.
- [Vibe Coding is Easy, Owning the Architecture Isn't](https://belderbos.dev/blog/vibe-coding-owning-architecture/): Generating code with AI is easy. Owning the architecture isn't. Why vibe coding creates the same trap as tutorial paralysis, and what to do instead.
- [From Hobby Code to SaaS to Orchestrating AI Agents](https://belderbos.dev/blog/ai-coding-tools-fundamentals-case-study/): Ryan Austin ships payroll software in the Bahamas. In 2021, he couldn't tell if his architecture was sound. In 2025, he's directing AI agents with confidence. The foundation made the difference.
- [How an AI expense agent is actually structured](https://belderbos.dev/blog/ai-agent-architecture-python/): LLM calls aren't magic. The four-layer architecture — Protocol, Pydantic, service layer, HITL — turns a chatbot into a production Python app.
- [Build Your First MCP Server: Code Tips in Claude and Slack](https://belderbos.dev/blog/build-mcp-server-python-tips-slack/): A step-by-step guide to building an MCP server in Python that surfaces your code tips collection inside Claude Code and a private Slack bot.
- [Stop Prompting, Start Structuring Your AI Workflow](https://belderbos.dev/blog/claude-code-skills-structured-ai-collaboration/): How I turned ad-hoc AI prompting into a repeatable coding workflow with Claude Code skills and a shared conventions file.
- [What Rust Structs Taught Me About State Ownership](https://belderbos.dev/blog/what-rust-structs-taught-me-about-state-ownership/): Rust's struct + impl separation forces you to think about state mutation in ways Python classes let you ignore. Here's what clicked.
- [Build a Finite State Machine in Python](https://belderbos.dev/blog/build-finite-state-machine-python/): Learn how finite state machines work by building one from scratch in Python. Guards, hooks, history tracking, and when to reach for a library instead.
- [How to Migrate Users Seamlessly Between Django Apps on Login](https://belderbos.dev/blog/login-triggered-user-migration-django/): How I migrated premium status, exercise progress, and token balances from a legacy Django app. Automatically, on first login, triggered by a Django signal.
- [From 1,069 to 156 LOC: Design Over Code](https://belderbos.dev/blog/design-over-code/): I built a 1,069-line Rust web app with AI in two sessions. Then I deleted it. The real productivity wasn't in the code, it was in the question I almost skipped.
- [How Modern Python Tooling Simplified My Setup](https://belderbos.dev/blog/modern-python-tooling-uv-ruff-ty/): uv, ruff, and ty replaced pip, venv, pyenv, black, isort, flake8, and mypy in my projects. Here's the before and after.
- [The Repository Pattern: Swap Data Sources in One Line](https://belderbos.dev/blog/repository-pattern-swappable-data-sources/): Use Python's ABC and a factory function to swap between live APIs, fake servers, and replay data without changing your app code.
- [What Building a JSON Tokenizer Taught Me About Rust](https://belderbos.dev/blog/what-building-a-json-tokenizer-taught-me-about-rust/): Learning Rust by building a JSON parser. Why a real project teaches pattern matching, state tracking, and debugging faster than exercises alone.
- [Learning Rust Made Me a Better Python Developer](https://belderbos.dev/blog/rust-made-me-a-better-python-developer/): Rust's ownership model, Result type, and exhaustive matching changed how I write Python. Here are the patterns that transferred.

## About

- [About Bob](https://belderbos.dev/about/): Background, experience, and coaching approach
- [Blog](https://belderbos.dev/blog/): Articles on Python, Rust, AI, and software engineering
- [Contact](https://belderbos.dev/contact/): How to reach Bob by email, call, or inquiry form (bob@belderbos.dev)
- [Book a call](https://calendly.com/bob-belderbos/chat): Free 30-minute call to discuss goals and fit
- [Privacy notice](https://belderbos.dev/privacy/): What the site collects and why

## Developer resources

- [pybites-search](https://pypi.org/project/pybites-search/): Open-source CLI (pip install pybites-search) to search Pybites articles, tips, and exercises from the terminal; source at https://github.com/bbelderbos/pybites-search
- [sitemap.xml](https://belderbos.dev/sitemap.xml): Machine-readable index of every URL on the site

## Optional

- [Pybites Platform](https://pybitesplatform.com): Interactive Python exercise platform with 400+ exercises
- [Rust Platform](https://rustplatform.com): Hands-on Rust exercises for Pythonistas
- [Pybites Books](https://pybitesbooks.com): Privacy-respecting reading tracker for developers