Thanks 🙏 @realpython for featuring my #Python + #Django design patterns article, where I walk through the design decisions behind my Commit Graph habit-tracking app. 🚀 I really liked how you framed it as a “this worked in this case, and here's why I did it” kind of article. Those are my favorite pieces to write. They help us move beyond “this library does X” toward “how should we think about software?” And I believe that kind of engineering judgment is becoming more of a moat these days as well. 🎧 Listen to the discussion here: realpython.com/podcasts/rpp/… I'm already working on Part II… 👀

Just published a new crate to crates.io: bob-json-parser 🦀 It's a JSON parser written from scratch in #Rust: a hand-written tokenizer and a recursive-descent parser, with no serde. PyO3 bindings let you call it from #Python as a native extension. It's the 6-week capstone of our cohort, and I built it alongside last cohort. I published it so I can use it in another tool I'm building that needs to parse JSON logs, simply: `cargo add bob-json-parser` Check it out -> crates.io/crates/bob-json-pa… Curious about leveling up with Rust? DM me or join our community -> scriptertorust.com

LLMs can write syntax, but they can’t replace human engineering judgment. As AI agents generate more of our codebases, live design sessions become *more* valuable, not less. Juniors still need to learn how experienced engineers THINK, something async code reviews only partially answers. Ensemble (mob) programming makes live architectural thinking, trade-offs, and micro-decisions visible in real time. I co-hosted live ensemble sessions back before AI agents, and developers loved verbalizing *why* they chose specific patterns. So I built a lightweight tool for it: 👉 Try the MVP: ensemble.belderbos.dev (zero installs and signup, Pyodide Python, driver/navigator timers) 👉 Help test drive it: belderbos.dev/community/ I'm curious to gauge interest: in an agentic world, do you feel the need for live, human-to-human design and coding sessions has grown? How would you use this? 👇

I just hand-coded a simple FSM (Finite State Machine) in #Python 💡 Some people might ask: It’s 2026. Why even code by hand? Because the thinking, debugging, and deeper understanding that go into an exercise like this are still valuable. I had to reason through the design, trace what was happening, debug it, and really understand the code. It's slower, but now I own it. And I can teach it better. It was also one of my happier moments this week. Only reading code and managing agents is not the same as being in touch with the code and understanding how something works at all levels. (I also had to explain Rust ownership / the borrow checker this week 💪) Now I'm going to do it again for my YouTube channel. We'll see how much hand-coding remains in the industry, but I do think regularly writing code yourself is a great way to keep your technical skills and intuition sharp. And judging by the feedback I get, this is also what people seem to value most in my videos: watching the thinking behind the code so the 'how' + 'why', not just the 'what'.

Scripter to Rust cohort: scriptertorust.com Rust coding platform: rustplatform.com

Learning #Python 🐍 syntax isn't the hard part. It’s everything around it where beginner devs typically get stuck: - the terminal / SSH keys, - git and the GitHub PR flow, - virtual environments, - dependencies and packaging, - writing your first tests, - linting, - etc. Overkill for a single script. But all needed for shipping / sharing an app. I'm building a free, self-paced 6-week course to help Pythonistas learn all this and more. We do that by building a command line app from scratch using these tools + workflows. Week 1 - Project Setup & Data Model - is live now 🎉 belderbos.dev/foundations/ Each Friday I'll launch the next week of content - more info in my launch post -> belderbos.dev/blog/free-pyth… Hope this helps more Python developers ship their projects with confidence. 🚀 Enjoy and any feedback welcome, let's go! 💪 🙏

My goto for a swappable backend in #python has been an abstract base class (ABC). There is a flexible alternative though: Protocol (typing module). Take LLM providers as an example. An ABC comes with a requirement: every provider has to inherit from your base class. Fine when you write every provider yourself, less so when they're third-party plugins. `typing.Protocol` uses "structural typing" instead. Conformance lives in the method shape, not in a shared base class. So a provider can evolve freely as long as the shape holds, and inherits no methods it doesn't use. And the type checker still catches a missing method or wrong signature at lint time. I still reach for ABCs when providers share concrete behavior, but protocols are the more flexible default. So next time ask: shared contract, or shared implementation? More in my new article: belderbos.dev/blog/protocol-…

AI made building fast. That includes building the wrong thing faster. Before writing code, you need a tight scope: what to build, and more importantly, what NOT to build. I built a simple tool to pressure-test your idea before you spend weeks building it:

What is the output of below Python (3.15) code and why? a. {'a': 1, 'b': 2, 'c': 4} b. {'a': 1, 'b': 99, 'c': 4} c. {'b': 99, 'c': 4, 'a': 1} d. TypeError

Code it here → rustplatform.com/mini-parser And share the 🥷 belt you've obtained with me (@bbelderbos) and @pybites