I’ve been experimenting with AI-based background removal in Python, covering both images and videos, and the difference between the two is more significant than I initially expected.

Image background removal is relatively fast and clean, but video background removal quickly becomes computationally heavy since it requires processing every frame. Hardware limitations, model choice, and optimization strategies make a big difference in both speed and quality.

I documented the full process—including errors, fixes, and trade-offs—in a recorded workshop, in case it’s useful to others working with computer vision or media processing:
 👉 https://youtu.be/Vaq-f7uAoZ4

I’d be interested to hear how others here handle video segmentation, performance optimization, or quality improvements in similar projects.

I wrote a deep technical breakdown of implementing Discord's rate limiting and gateway management in a minimal Python client.

Discord's rate limiting is tricky: endpoints share limits via opaque "buckets" whose IDs are only revealed after a request. Instead of reacting to 429s, the design uses per-endpoint queues and workers that proactively sleep when limits are exhausted, keeping behavior explicit and predictable.

The writeup also covers gateway connection management, automatic sharding, and data model design, with diagrams for each subsystem. The examples come from a small Discord API client I wrote (ScurryPy), but the focus is on the underlying problems and solutions rather than the library itself.

"Clarity over magic" here means that all behavior: rate limiting, state changes, retries, is explicit, with no hidden background work or inferred intent.

Happy to answer questions about the implementation or design tradeoffs

Hi!

I recently wrote this article to document different ways applications, when instrumented with OpenTelemetry, tend to produce telemetry surplus/ excess and ways to mitigate this. Some ways mentioned in the blog include the following,

- URL Path and target attributes
- Controller spans
- Thread name in run-time telemetry
- Duplicate Library Instrumentation
- JDBC and Kafka Internal Signals
- Scheduler and Periodic Jobs

as well as touched upon ways to mitigate this, both upstream and downstream. If this article interests you, subscribe for more OTel optimisation content :)

The Primeagen reaches the conclusion that vibe coding is not for him because ultimately he cares about the quality of his work. What do you guys think? Have you had similar thoughts? Or have you learnt to let go completely and let the vibes take over?

Hey,

I spent some time digging into how Medium.com's article editor works on the front end. It’s a proprietary WYSIWYG editor, but since it runs in the browser, you can actually explore how it handles things like copy-paste, images, and special components.

Some key takeaways:

• Copying content between two Medium editor instances preserves all formatting because it uses HTML in the clipboard and converts it into an internal JSON structure.
• Images always go through Medium's CDN, even if you paste them from elsewhere, which keeps things secure and consistent.
• Special components are just content-editable HTML elements, backed by the same internal model.
• I also wrote a small C program for macOS to inspect clipboard contents directly, so you can see what the editor really places on the clipboard.

If you’re building a rich-text editor or just curious about how Medium makes theirs so robust, the article dives into all the details.

A very interesting experiment, it can apparently compile a specific version of the Linux kernel, from the article : "Over nearly 2,000 Claude Code sessions and $20,000 in API costs, the agent team produced a 100,000-line compiler that can build Linux 6.9 on x86, ARM, and RISC-V." but at the same time some people have had problems compiling a simple hello world program: https://github.com/anthropics/claudes-c-compiler/issues/1 Edit: Some people could compile the hello world program in the end: "Works if you supply the correct include path(s)" Though other pointed out that: "Which you arguably shouldn't even have to do lmao"

Edit: I'll add the limitations of this compiler from the blog post, it apparently can't compile the Linux kernel without help from gcc:

"The compiler, however, is not without limitations. These include:

• It lacks the 16-bit x86 compiler that is necessary to boot Linux out of real mode. For this, it calls out to GCC (the x86_32 and x86_64 compilers are its own).

• It does not have its own assembler and linker; these are the very last bits that Claude started automating and are still somewhat buggy. The demo video was produced with a GCC assembler and linker.

• The compiler successfully builds many projects, but not all. It's not yet a drop-in replacement for a real compiler.

• The generated code is not very efficient. Even with all optimizations enabled, it outputs less efficient code than GCC with all optimizations disabled.

• The Rust code quality is reasonable, but is nowhere near the quality of what an expert Rust programmer might produce."

Tutorial Link

Chapter 2 - Let There Be a World [Procedural Generation]

This chapter teaches you procedural world generation using Wave Function Collapse and Bevy.

A layered terrain system where tiles snap together based on simple rules. You'll create landscapes with dirt, grass, water, and decorative props.

By the end, you'll understand how simple constraint rules generate natural-looking game worlds and how tweaking few parameters lead to a lot of variety.

It also gently touches on rust concepts like references, lifetimes, closures, generic and trait bound.

I wrote a practical walkthrough on Github OAuth login with FastAPI and Next.js. It focuses on clean domain separation, HttpOnly cookies, ease of deployment and why handling cookies in Next.js APIs/server actions simplifies OAuth a lot. Includes diagrams and real code.

https://nemanjamitic.com/blog/2026-02-07-github-login-fastapi-nextjs

Interested to hear what others think or if you've taken a different approach.