This week’s collection highlights several key advancements in Azure performance, the nuances of orchestrating multiple AI agents, and critical updates to NuGet security. These pieces offer practical insights for anyone looking to streamline their development workflow while maintaining a more secure infrastructure.
Cloud
Azure Service Bus: Count your filters (Daniel Marbach) - Great deep post about performance. The architecture and number of filters can and will greatly affect the performance.
This week’s notes focus heavily on the practicalities of building reliable AI agents, specifically looking at how we manage their memory and governance. I have also included a few notable wins in Azure storage performance and some honest reflections on where our industry is heading next.
AI
AI Governance: Runtime Enforcement, Not Runtime Advice (Karan Verma) - I'm impressed by our journey of using AI. Not long ago, we barely trusted it, and now it's running independently, and we think more about limiting what it can do. Nice second post o to a series.
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
I’ve gathered a few insightful pieces this week exploring smarter ways to manage AI costs, practical hardware setups, and the foundational logic behind better programming. Each link offers a different perspective on how we can refine our workflows and think more intentionally about the tools we use every day.
Set up OpenClaw on your Raspberry Pi (Lucy Hattersley) - Tease about a very interesting post (available in the Raspberry Pi Official Magazine) more to come
The Power Of “Why?” (codemanship) - A great post that reminds us that asking the right question helps us understand the real need and build better solutions.
This week's highlights bring together insights on evolving API security, the realities of integrating AI into your workflow, and tools that can help streamline the testing process. I selected these pieces for their practical advice on simplifying everyday development tasks while building more robust and resilient infrastructure.
Programming
Web Application & API Protection: An Overview (John Brawner) - I knew many security tools existed, and obviously I use some. But I learned a lot in this post. WAAP emerged because WAF alone was not enough to address APIs, bots, DDoS, and modern cloud traffic patterns in a single runtime protection model.
AI is ready. Your APIs probably aren't (Matt Gray) - Postman has always been an interesting tool. I've been using something else for a while but am thinking about exploring it again!
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
This week's collection highlights several practical upgrades for your workflow, ranging from cleaner C# patterns to more secure ways to manage AI agents. I’ve also included a few podcast episodes and articles that offer some much-needed perspective on productivity and community life.
AI
Why AI Agents Need Isolation with Docker SBX (Karan Verma) - Power comes with responsibilities. It's well known (at least for Spider-Man fans), but more seriously, AI users have a simple way to stay safe. And now, with "the kits", it looks like it's even easier.
Using AI to Build a Blazor App 1: Start With the Problem (Jon Hilton ) - It's so true that AI doesn't always do or act the way we expect. In this case, I wonder if a different model would have been better. In my experience, GPT is better at doing things compared to brainstorming.
New: Versioned CLI and SDK Docs (Cam Soper) - That's a nice feature that more should implement! You pick your API version, and the documentation follows.
Goodbye, forever, probably. (Salma) - Sad news for the communities, but at the same time, it's because of those same communities. This post shares a very sad portrait of the online world that affects many people.
This week’s collection features a mix of critical .NET lifecycle updates and practical strategies for optimizing your database interactions. These selected articles offer helpful insights into everything from edge computing deployments to the evolving landscape of AI in modern workflows.
AI
AI Raised the Bar (And Now We're All Tired) (Golnaz) - It's so true! So much can be done quickly today. An interesting question is: how do we avoid burning out resources and tokens? How, as human we stay smart? After all, life is a marathon, not a sprint!
EF Core vs Dapper in .NET: When to Use Each (Nick Cosentino) - Great post for developers or architects planning a future project. Both tools are great, so the decision factor depends on the context.
This week’s collection highlights practical ways to improve developer workflows, from faster test runs and more manageable pull requests to intuitive new AI integrations. I have gathered a few standout articles on Blazor components, Azure Functions updates, and the nuances of training coding agents for your specific stack.
Suggestion of the week
Stop overloading your skills - Microsoft for Developers (Waldek Mastykarz) - The post ends with: "In many cases, models don’t need a textbook. They needed a cheat sheet." It's so true! And this post explains why and how to validate it.
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
I spent some time this week tracking new developments in the AI and DevOps space to see what was worth a closer look. These notes highlight several interesting pieces regarding new model releases, infrastructure shifts, and more efficient ways to manage your project files.
Introducing North Mini Code: Cohere’s First Model For Developers (Cohere Code Agents Team) - I feel like those new model blog posts are never simple to read. They are packed with numbers, statistics and comparisons with things you may not have known before. But that's what makes them interesting; they are a deep source of information. And yes, that model looks great!
Exploring the SLNX Solution File Format (Dave Brock) - The new format has been out for a while now, and I use it in more and more projects. Much easier to read.
Every time I set up Neovim on a fresh WSL instance, I hit the same wall: yanking text inside Neovim and pasting it into a Windows app (or vice versa) just doesn't work. "+y does nothing, and Neovim greets you with Clipboard: No provider, try :checkhealth. Nothing flows in or out of the clipboard, not even between files inside WSL.
The root cause is that WSL's Neovim can't talk to the Windows clipboard at all. The fix is a tiny Windows executable called win32yank that speaks the Windows clipboard API from the command line.
I've done this enough times now that I'm writing it down so I never have to search for it again. If you're here for the same reason, this one's for you.
Step-by-Step
1. Download win32yank
Grab the latest release from github.com/equalsraf/win32yank. Download win32yank-x64.zip and extract it to get win32yank.exe.
2. Place it in your WSL PATH
sudo mv /mnt/d/win32yank.exe /usr/local/bin/
Adjust the source path to wherever your browser downloaded it (usually /mnt/c/Users/<you>/Downloads/win32yank.exe).
This week’s compilation explores a mix of critical topics ranging from integrating AI models with SQL Server to navigating the complexities of Azure container troubleshooting. I’ve selected these particular articles because they offer practical ways to streamline your workflow and better understand the latest shifts in cloud infrastructure and software development.
Learn Anything With My /teach Skill (Matt Pocock) - I use AI to learn many times, but I didn't think doing a skill. Looking forward to trying it.
How AI coding agents actually use your technology - Microsoft for Developers (Waldek Mastykarz) - A very interesting post that explains all the steps executed by VS Code harness when we submit our prompt. The post also provides some insights on why AI could still get bad results even if we provide SDK and MCP servers.
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
Modern infrastructure and AI agent development move fast, requiring a sharp eye on both backend stability and frontend polish. This week’s curated notes highlight critical shifts in observability, security best practices for autonomous agents, and practical updates for .NET MAUI apps. Check out these essential reads to stay ahead of the curve.
Why Choose Pulumi Over Terraform? (Pablo Seibelt) - I have never tried Pulumi or terraform, but they look great, and after reading this post, I'm very interested in learning more about ballooning
When I started taking notes about the articles I was reading, I never imagined I would still be doing it 700 weeks later.
Back then, my notes lived on a USB key. I carried a small personal wiki with me and used it to save interesting articles, ideas, and discoveries. It was a simple way to build my own searchable knowledge base so I could find things again when I needed them.
In 2011, I started sharing those notes publicly on my blog, Franky's Notes. A few months later, I made another important change: I switched from writing in French to writing in English. At the time, I wasn't fluent, but I wanted to improve. "Notes de lecture" became "Reading Notes", and every week became an opportunity to learn something new while practicing a language that would eventually become a big part of my career.
Over the years, the format evolved. Articles were joined by podcasts, books, videos, and whatever else helped me learn and stay curious. Technology changes constantly, and one of the things I enjoy most about working in this industry is that there is always something new to discover.
What never changed was the habit itself.
Most mornings start the same way: a coffee, my e-reader, and a few articles. Throughout the week, I collect the things that made me think, taught me something, or simply felt worth sharing. Then, every Monday, I publish a new edition.
Seven hundred weeks later, these reading notes have become much more than a list of links. They are a record of what caught my attention, what I was learning, and how both technology and I have changed over the years.
If you've been reading along for a while, thank you. If you're new here, I hope you discover something interesting in the links below.
Suggestion of the week
Harness, Scaffold, and the AI Agent Terms Worth Getting Right (Sergio Paniego, Aritra Roy Gosthipaty) - This post shares a list of definitions. If you feel like there are some terms used in the "AI world" that you are not sure what they mean, this post is for you.
An important update: Transitioning Gemini CLI to Antigravity CLI - I migrated this week to Antigravity IDE 2.0, and it works great. I had an intense coding session with the CLI (thanks to the crappy weather), and it just worked! No issues, no adaptation, no conversion. 5/5
This week's reading notes bring you the latest insights into AI, .NET, open-source development, and even a few social hacks! From exploring background tasks in Blazor to the fascinating debate on Markdown vs. HTML for AI output, this roundup has something for everyone.
Let me know if you find anything particularly interesting; I'd love to hear your thoughts!
Anthropic Engineer Debates Use of Markdown vs. HTML in AI Agent Output (Paul Thurrott) - Interesting debate. Initially, I was hell no! But the more I think about it, the less certain I am. But we can always ask to generate HTML, so I guess it's okay to keep it lighter and more minimalist by default.
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
The world of AI is exploding, and with that explosion comes a crucial question: how do we keep these powerful agents in check? Traditional security methods might not cut it anymore, so developers are turning to innovative sandboxing techniques. Let's explore some of the most promising approaches and see which ones emerge as the frontrunners in this AI safety race.
Use What Works with Dylan Beattie (.NET Rocks!) - This episode will provide great information for anyone who is interested in using an open source project to build their solution. You should not see OSS as only being free, and you should consider how you can help the maintainers.
AI SREs, Chat With Your Infrastructure with Anyshift (Agentic DevOps : AI Engineering for Infrastructure) - An interesting tool that Anyshift.io that digs into our infra to build a diagram and helps us to see. See what works and understand what doesn't. I might go try the free trial.
The Science of Achieving Goals: How to Change Your Life in 5 Simple Steps (The Mel Robbins Podcast) - We all have goals, some are attainable faster than others. For those goals that require more planning, this episode shares simple steps (very simple indeed) to achieve them. It's explained as only Mel can do it.
I've made it a habit to share the fascinating articles, blog posts, and books that cross my path each week. Think of this as an open invitation, if you stumble upon something intriguing, don't hesitate to share it! Let's build a community of curious minds.
This week’s reading notes cover a wide range of topics, from local AI workflows and Docker agent fleets to data privacy, SQL tips, and developer tooling updates. There’s also an interesting look at how AI may be reshaping platforms like GitHub, alongside practical articles and podcasts packed with ideas for developers and tech enthusiasts alike.
Ghostty Is Leaving GitHub (Mitchell Hashimoto) - I didn't realize it was that bad! It's true that I spend less time there, but did AI cause all those outages (by generating peaks of traffic)
Docker AI, what’s new with MCP, Agents, Sandboxes, and more (DevOps and Docker Talk: Cloud Native Interviews and Tooling) - Michael Irwin from Docker is on this episode and they go through alllll the recent releases and some major upcoming stuff, rellay interesting episode
Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.
I was wearing a t-shirt with a partial Reka logo at the edge of the frame. I never said the word "Reka" in that segment. The model caught the logo, connected it to the topic I was discussing, and mentioned it unprompted in the output it generated.
That is not a transcript trick. The model was watching.
At the AI Agents Conference 2026, I gave a talk called "Apps That See" — six live demos showing how to build applications that understand images and video. Every project is open source and ready to clone. This post walks through each one so you have enough context to pick it up, run it, and adapt it to something useful in your own work.
Vision AI Is Accessible Now
Not long ago, working with visual AI meant GPU clusters, specialized teams, and weeks of training. Today a compressed 4B model like Qwen or Gemini 3 runs on a regular laptop and handles image description well enough to prototype. Step up to a 7B model like Reka Edge and the quality improves meaningfully. It also runs locally: a gaming PC with a decent GPU is enough. No server required.
For tasks that need more power, cloud APIs give you faster results without local hardware requirements. The tradeoff is that your images and video go to a third-party provider. For corridor cameras or stock photos that is usually acceptable. For private or sensitive content, local is the better default.
The practical pattern: start local to build and test, then decide whether the task actually requires cloud.
What You Can Build With This
Accessibility: Describe a scene in real time for visually impaired users, or identify objects on demand.
Content creation: Extract structure from a video and turn it into a blog post, caption set, or highlight reel.
Productivity: Search through thousands of videos for a specific object or topic, even when the title gives no indication of the content.
Automation: Trigger actions only when specific visual conditions are met, such as an unrecognized person entering a room.
Fun: Most developers' first contact with AI is building something for themselves, and that is a perfectly valid starting point.
Demo 1: Caption This — Generate a Prompt from Any Image
If you work with image generation models, you end up with a lot of images to test and compare. Writing the text prompt that would reproduce a specific image is tedious. This tool does it for you: give it an image, get back a prompt you can use to regenerate something similar.
The demo uses an HTTP client extension in VS Code to call the API directly, no SDK. Pass an image, ask for a plain-text prompt that would recreate it. One prompt detail that improved results noticeably: add no markdown to the instruction.
POST https://api.reka.ai/v1/chat
Content-Type: application/json
{
"model": "reka-flash",
"messages": [{
"role": "user",
"content": [
{ "type": "image_url", "image_url": { "url": "https://..." } },
{ "type": "text", "text": "Write a prompt in plain text, no markdown, that would generate the exact same image." }
]
}]
}
One thing to know when testing this across different models: some accept an image URL directly, others require the image as a base64-encoded string. Same task, same prompt, different input contract. If you plan to swap models in your app, account for this difference from the start.
Demo 2: Media Library — Compare Vision Models Side by Side
This is a web app that connects to multiple vision backends and lets you switch between them at runtime. The motivation: benchmark Reka Edge running locally — via OpenRouter or directly through the Reka API — against other models on real tasks.
Object detection surfaces the biggest portability problem. Some models return bounding boxes in an HTML-style bracket format with pixel coordinates. Others use a 2D box structure with a different coordinate scheme. If you code against one format and then swap models, your rendering breaks. There is no standard here — handle the differences at the application layer, not the model layer.
The app uses the OpenAI API format as the common interface across all backends. Any model with a compatible endpoint can be swapped in with minimal changes. It does not eliminate the per-model quirks, but it reduces the friction of switching to a configuration change rather than a rewrite.
Video input is supported too, though far fewer models handle it than images. Of the models tested, Reka Edge is the standout for video — the others either reject it or behave inconsistently.
Demo 3: Video2Blog — Turn a Video into a Structured Post
I built this for myself. I do a lot of tutorial videos and I wanted a tool that would turn a recording into a structured blog post without me having to write one from scratch.
The tool sends the video to a vision model with a detailed prompt: target structure, tone, format, and an instruction to flag moments where a screenshot would add value. The model returns timestamps — it cannot extract frames itself, but it tells you exactly where to look, and you pull them locally with ffmpeg.
That creates one architectural quirk worth knowing: the video lives in two places. ffmpeg needs it locally to extract frames. The hosted model needs it uploaded to analyze content. For a one-evening project it works well enough, and I use it often enough that it has paid for itself many times over.
After the first draft, you stay in a conversation loop: change the tone, translate to French, swap a timestamp, restructure a section. The model holds context and iterates with you until the result is what you want.
Demo 4: Video Analyzer — Search and Query Your Video Library
Most video search runs on titles, descriptions, and transcribed audio. This demo searches by what is actually visible on screen.
The app pre-indexes a video library by sending each video through a vision model ahead of time. When a query arrives, the heavy work is already done. A search for "robot arm" returns the right video — a clip of a robotic arm animation. It also returns a false positive: fast-moving hands apparently looked close enough to fool the model. Useful, not perfect, and worth designing around in your UX.
The Q&A feature goes further. You pick a video and ask a specific question. "What database was used?" returned MySQL — and noted it was running in a Docker container. The model identified that from watching the screen, not from audio. No transcript needed.
From there, you can generate study materials from any recorded session. The demo produces a multiple-choice quiz with answer options, correct answers, and explanations. The model is doing comprehension, not transcription.
Demo 5: Roast My Life — What the Model Actually Sees
I never mentioned the pictures on my wall. The model did.
In a video about Python and AI, the model's generated blog post made a remark about the artwork hanging behind me. I had said nothing about it. The model noticed, mentioned it, and moved on as if it were obvious.
Then there was the t-shirt moment described at the top of this post. A partial logo, half out of frame, no mention of it anywhere in the audio — and the model connected it to the topic anyway.
This demo is named Roast My Life because the model ends up commenting on things you never intended to share. But the real point is what it reveals: a vision model is not a smarter transcript. It is watching. The larger models do this particularly well, and once you see it, it changes how you think about what these tools can do — and what they will pick up without you asking.
Demo 6: N8N Automation — No-Code Video Clipping Pipeline
Vision AI does not always need custom code. This demo wires everything together in N8N, a visual workflow tool, with no programming required.
The trigger is a new video published to YouTube. The workflow finds an engaging clip, reformats it from horizontal to vertical, adds captions in a specific style (all lowercase, specific colors — chosen to be obviously distinct from any default), and sends an email with the finished clip attached. The whole thing runs automatically.
For developers, this pattern is worth knowing even if you code everything else. Many real business workflows have a vision AI step that fits cleanly into a larger automation, and a no-code tool is often the fastest way to ship it.
Watch the Full Talk
The demos above are the written version. The live version, with the actual code running, models responding in real time, and a few things going sideways in interesting ways, is on YouTube.
All the Code
The demos span Python, C#, raw HTTP, Go, and N8N. Vision AI is not tied to a specific stack — if your environment can make an HTTP request, it can call a vision model.
This week's collection highlights the rapid evolution of AI agents, exploring their asynchronous capabilities, deployment journeys, and their impact on DevOps and video editing. On the programming front, we explore new Git features and API versioning with OpenAPI in .NET 10. We also dive into some fascinating podcast discussions ranging from the GUI vs. CLI debate to generational perspectives in the workplace.
510: AI Agents: Claws, Copilot, GUI vs CLI Debate (Merge Conflict) - In this episode, James is put in the spotlight and needs to talk about this phone situation. Honestly, interesting discussion and they finally end up talking about the AI agent, you know, CLI versus UI.
Can AI Agents Safely Become DevOps Engineers? (Agentic DevOps : AI + Infra Ops) - I read and consume a lot of AI as a developer, it's interesting to see the DevOps side waking up and are building AI agents that focus on DevOps.
Chet Husk: .NET Tooling - Episode 399 (AI DevOps Podcast) - I never thought about that competition, the human versus the machine, related to the consumption of the output of a CLI. This was a very interesting episode about the performance and the priorities.
A mix of thoughtful perspectives and practical updates this week. From evolving AI tools and model selection guidance to changes in developer workflows and tooling, there’s plenty to reflect on. Add in insights on streaming and a strong push toward more secure environments, and you get a well-rounded set of reads worth your time.
Changes to GitHub Copilot Individual plans (Joe Binder) - Big changes for Copilot that will probably affect your workflow. This post shares the details and reasons of this disturbance; it's all for a good reason
It's Time for a Visual Studio Upgrade - This post does a comparison between the old and the new versions of the Visual Studio IDE and shares details about the most impactful changes.
Miscellaneous
Livestreaming Before It Was Cool (Golnaz) - Curious to learn more about the streaming options from the different platforms to the tools, and the pro and cons of each? This post is for you, and on top of that, you get the Microsoft story.
A fast-moving mix this week: AI tooling, ARM readiness, Docker sandboxes, and real-world lessons from agents. Practical insights across .NET, DevOps, and local-first workflows.
Our Favorite Agent Setups (Agentic DevOps) - Nice discussion that goes through many AI harnesses, agents, models, and what they are playing with right now. OpenClaw, OpenCode, Claude Code, Copilot, and all of it.
I'm always on the lookout for innovative ways to enhance my coding experience, and this week's Reading Notes are filled with exciting discoveries! From cutting-edge UI libraries to secure sandbox environments for AI agents, I've curated a selection of articles that showcase the latest programming trends and technologies.
Whether you're interested in harnessing the power of Docker sandboxes or exploring the potential of smart glasses integration, there's something on this list for everyone.
