# Nizar's Blog

> Personal technical blog by Nizar Selander on software development, AI and LLM workflows, web performance, and security.

Each post links to its Markdown source. A single-file bundle of every post is available at https://nizar.se/llms-full.txt. There is also an Atom feed at https://nizar.se/feed.xml and a sitemap at https://nizar.se/sitemap.xml.

## Posts

- [Look Smarter With Git: Rewriting Your History](https://nizar.se/look-smarter-with-git-rewriting-your-history.md): As developers, we are encouraged to commit code changes early and frequently. A benefit of which is being able to revert to previous states when needed. This luxury, however, can come at the expense of a rather messy Git history; one that communicates how the intended changes were reached rather than what they are.
- [Serving Sites with NGINX QUIC](https://nizar.se/serving-sites-with-nginx-quic.md): A quick look at QUIC and how to use NGINX’s newly released pre-built packages to enable it for your site.
- [Improving Website Speed with Compression](https://nizar.se/improving-website-speed-with-compression.md): Compression plays a vital role in the modern web. It helps us deliver content faster to users while preserving network resources. With technologies like Gzip and Brotli, we can make websites more efficient without compromising the quality of the data. In this post, we will explore how to improve website speed by leveraging HTTP compression and pre-compressing files.
- [Striving for Performance and Design Harmony in Web Development](https://nizar.se/striving-for-performance-and-design-harmony-in-web-development.md): In modern web development, a fine balance between performance and user-centric design is key. It doesn't just enhance visitor retention; it deepens their interaction with the content. My recent project provided me a deep dive into achieving this delicate balance. Here is a recount of my experience and the insights that I’ve gained.
- [Robot Control with the Jetson Nano](https://nizar.se/robot-control-with-the-jetson-nano.md): Two years ago, I got to dive into a project at the intersection of machine learning and hardware - right before ChatGPT became a household name and when terms like overfitting puzzled me. Nonetheless, I was really excited about it, especially because it involved both software and hardware, a combination Im quite fond of.
- [Optimizing GitHub Workflows for Efficiency and Sustainability](https://nizar.se/optimizing-github-workflows-for-efficiency-and-sustainability.md): Integrating automation into development workflows has become crucial in recent years. In this post, I'll share a few strategies I've found useful for making these workflows both more efficient and sustainable. We'll look into strategies such as canceling redundant jobs, setting appropriate workflow timeouts, optimizing caching techniques, and managing workflow triggers more effectively.
- [Supply Chain Security Risks in Static Sites](https://nizar.se/supply-chain-security-risks-in-static-sites.md): Static sites are perceived as more secure than their dynamic counterparts due to their simplicity and lack of server-side components. However, this perception can lead to overlooked threats, particularly those introduced by third-party libraries and services. In this article, we'll explore how these vulnerabilities arise and how you can defend your site against them.
- [Implementing Durable Entities in Kotlin](https://nizar.se/implementing-durable-entities-in-kotlin.md): This series explores how to implement Durable Entities in Kotlin, which are stateful objects that manage their own state and enable seamless persistence and resumption in serverless workflows. Though not natively supported in Kotlin, this series provides a step-by-step guide to replicating their functionality using orchestration instances. The series covers topics such as managing state, signaling entities, and cross-entity communication.
- [Implementing Durable Entities in Kotlin - Persisting State](https://nizar.se/implementing-durable-entities-in-kotlin-persisting-state.md): Durable Entities require a structured way to reference specific instances. This post introduces Entity IDs, which uniquely identify entity instances, and refines entity creation with a lightweight abstraction. By aligning with how Durable Entities are structured in other languages, we make instance creation more intuitive while keeping the implementation clean and flexible.
- [Implementing Durable Entities in Kotlin - Creating Entities](https://nizar.se/implementing-durable-entities-in-kotlin-creating-entities.md): So far, we've learned how Durable Entities can persist state across executions and conserve resources, and we've used custom status and metadata to manage state for a basic counter entity. In this post, we'll build on that by introducing Entity IDs which are unique identifiers that allow us to create and interact with specific entities. By abstracting entity creation into a reusable pattern, we simplify the process and prepare for handling operations efficiently in upcoming posts.
- [Implementing Durable Entities in Kotlin - Signaling Entities](https://nizar.se/implementing-durable-entities-in-kotlin-signaling-entities.md): Durable Entities remain active across executions, but without external input, they are static. This post introduces signaling, a one-way communication method that enables entities to react to events dynamically. Using a Counter example, we extend our entity to listen for increment and reset operations, making it interactive. By the end, our counter will respond to external requests, laying the foundation for more advanced event-driven workflows.
- [Implementing Durable Entities in Kotlin - Signaling Entities with Input](https://nizar.se/implementing-durable-entities-in-kotlin-signaling-entities-with-input.md): Signaling allows entities to process operations dynamically, but until now, signals have been limited to simple operation names. In this post, we extend our implementation to support input data, enabling entities to handle structured commands. By passing values with signals, our counter can now process operations like adding a specified amount. This enhancement brings our entities closer to real-world applications where interactions require more than basic state changes.
- [Implementing Durable Entities in Kotlin - Cross Communication](https://nizar.se/implementing-durable-entities-in-kotlin-cross-communication.md): Entities in a distributed system often need to collaborate, but Durable Functions impose constraints on direct communication. In this post, we introduce cross-entity signaling while maintaining orchestration integrity. By implementing a monitor entity that listens for updates from a counter, we explore structured signaling models, activity functions, and best practices for reliable inter-entity communication in Kotlin.
- [Implementing Durable Entities in Kotlin - Calling Entities](https://nizar.se/implementing-durable-entities-in-kotlin-calling-entities.md): So far, our Durable Entities have interacted through signaling, but they lacked direct, two-way communication. In this post, we introduce entity calling, enabling entities and orchestrations to request operations and receive responses. This addition unlocks new possibilities, such as querying state, making informed decisions, and structuring workflows with real-time interactions—all while preserving Durable Functions constraints.
- [Implementing Durable Entities in Kotlin - Final Enhancements](https://nizar.se/implementing-durable-entities-in-kotlin-final-enhancements.md): Throughout this series, we've explored Durable Entities from the ground up: managing state, creating entities, signaling, cross-communication, and two-way interactions. There steps have culminated in a flexible and functional system for handling stateful workflows in Kotlin. In this final post, we'll refine and enhance our implementation. By introducing abstractions and a DSL-like syntax, we'll improve readability, and aligns it with the native experience. This consolidation will prepare our implementation for real-world usage and future expansions.
- [How I Use LLMs as a Developer](https://nizar.se/how-i-use-llms-as-a-developer.md): I have been using Large Language Models (LLMs) for the last two years. During this time, I’ve noticed that people’s opinions about LLMs vary dramatically. The community seems split—some developers swear by them, while others remain skeptical or outright dismissive. Personally, I find these differences fascinating because they highlight that there’s no single “right” way to think about LLMs, and definitely not a single right way of using them. Instead, the value you get largely depends on how you choose to approach them.
- [Agentic TDD](https://nizar.se/agentic-tdd.md): Since I started programming, I've insisted on always writing my own code. It wasn't out of necessity; it was a personal choice. Even as LLMs (Large Language Models) became part of my workflow, I stayed firm about handling production code myself. Last week, that changed.
- [TDD Guard for Claude Code](https://nizar.se/tdd-guard-for-claude-code.md): Claude Code fit well into my workflow, but sticking to Test-Driven Development (TDD) principles still needed occasional reminders: one test at a time, fail first, no over-implementation. It worked, but it wasn’t effortless. So I built TDD Guard, a utility that handles that for me and keeps my attention focused on designing solutions rather than policing TDD.
- [Lean Claude Code for Production](https://nizar.se/lean-claude-code-for-production.md): Many agentic coding demos showcase landing pages, one-off scripts, or greenfield projects. While technically impressive, they often produce single files with little thought for maintainability. Even OpenAI's ChatGPT 5 launch demo followed this pattern. At the other extreme, some content focuses almost entirely on elaborate integrations and orchestrations.
- [The Code is the Context](https://nizar.se/the-code-is-the-context.md): Most advice on working with agents focuses on orchestration and interaction strategies. But I keep finding renewed significance in the software development fundamentals we've always known. After all, agents don't just respond to how we prompt them, they also respond to what they find in the codebase.

## Pages

- [About Nizar Selander](https://nizar.se/about/): Who Nizar is, his work, and how to get in touch.