Dives into the intersection of AI and development, exploring tools like GitHub Copilot’s AGENTS.md and the MCP Toolkit for automations, alongside .NET 10.0’s performance gains and OpenAI’s recent updates. Whether you’re optimizing serverless APIs with AWS Lambda or mastering the Web Animation API, this post highlights breakthroughs in code efficiency, model customization, and cloud innovation. Dive into these thought-provoking reads to stay ahead in a rapidly changing world.
Add MCP Servers to Claude Code with MCP Toolkit (Ajeet Singh Raina) - Very cool way to create automations. I have used a lot of low-code and different alternatives to create automation workflows in the past, but this mCP server interactivity is pretty awesome.
Low-Rank Adaptation (LoRA) Explained (Ignasi Lopez Luna) - Nice post that shows how we can specialize a model ourselves for a very narrow, specific topic
The Web Animation API (Christian Nwamba) - It's the first time I've read about this web animation API, pretty cool even if we need to be careful, I think that precision offers could be very interesting for some animations.
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 explores the synergy between Dapr and WebAssembly for modern microservices, highlights the transformative potential of Wasm 3.0 for .NET developers, and delves into best practices for structuring Rust web services. In the AI realm, we examine the emergence of developer-friendly AI frameworks like Microsoft’s Agent Framework and Google’s Jules Tools, which bridge AI capabilities directly into terminals and workflows. Additionally, we examine AI obfuscation techniques and their implications, alongside updates on Perplexity’s free Comet AI browser and its new background assistant. Whether you’re building scalable systems, optimizing code, or integrating cutting-edge AI tools, this post offers a snapshot of trends shaping tech today.
Obfuscation for AI: How it Works, Best Practices, and Metrics – PreEmptive (preemptive) - It's been a while since I last used a station in my code because I'm doing demos most of the time, but it always fascinated me. I feel I should try it with AI, it looks very interesting and powerful. This post shares a lot about what's possible, the risk, and so much more
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 covers Microsoft’s open-source Agent Framework for agentic AI, prompt-injection risks and mitigations, and the causes of language model hallucinations. It also highlights NuGet package security updates, Azure SQL Data API Builder improvements, Reka’s new Parallel Thinking feature, and the latest in AI benchmarking.
MCP Prompt-Injection: The Trust Paradox in AI (Saurabh Davala, Sundeep Gottipati) - This is a good post to learn to start learning about the real danger. To be aware of the potential risk and learning about what we can do.
Why language models hallucinate - Very interesting post that explains the reason why we still have hallucinations and how it works
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 post explores the intersection of AI, cloud, and DevOps, featuring updates on Microsoft’s Logic Apps integration, practical .NET tools for system automation, and strategies to enhance documentation for AI-driven workflows. Whether you’re refining enterprise security practices with NuGet’s Trusted Publishing or diving into the ethical nuances of AI through vector databases, this post offers a blend of technical deep dives and thought-provoking discussions. Don’t miss the podcast highlights, from DevOps innovation to the business impact of employee well-being, perfect for developers, architects, and curious minds alike. Let’s connect the dots in a world where code, creativity, and collaboration drive progress.
Prompt Files and Instructions Files Explained - .NET Blog (Wendy Breiding) - One question I often hear is how can I tell Copilot the standard and conventions my enterprise uses. Well, now I can send them to this post. Well done!
ohn Bristowe: The Latest from Octopus Deploy - Episode 368 (Azure & DevOps Podcast) - Loved this episode, I don't know a lot about Octopus. Discussing deployment pipelines, AI integration in DevOps, and the evolution from manual weekend deployments to automated, reliable workflows.
The business case for employee well-being (Modern Mentor) - Really enjoyed this episode on how workplace wellbeing isn't just about perks but building better work systems that boost both results and employee experience
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.
Welcome to another edition of my reading notes! This week I've gathered some interesting finds across programming, AI, and general tech topics. From exciting Cake updates to practical AI implementation advice, here are the articles that caught my attention recently.
Programming
Cake.Sdk 5.0.25257.82-beta released (devlead) - I'm happy to see the new release of this cake version coming to a recent .NET version. I have one of my projects using cake, and I was waiting for it; this is amazing
AI
Performance Improvements in .NET 10 (Stephen Toub) - There's a lot of good advice in this post. Assuming you're using AI you should definitely read 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.
In this edition, we explore modern development's evolving landscape. From Microsoft's .NET Aspire simplifying distributed applications to AI security considerations, Git workflow optimizations, and backlog management strategies, there's something here to spark your next breakthrough.
The tech world never sleeps, and neither does innovation. Let's explore what caught my attention this week and might just spark your next big idea or solve that problem you've been wrestling with.
Identity and Access Management for .NET (Khalid Abuhakmeh) - This package looks very interesting to add multiple handlers to an HTTP client. The first question that pops in my mind is why this is not already in .NET, I think it should. I'll definitely give it a try.
AI Injection Attacks (ericlaw) - Great post that talks about the current risk when using AI and how we should try to do our best to protect the important information.
How to Get Things Done, Stay Focused, and Be More Productive (The Mel Robbins Podcast) - This compelling episode (available in audio and video) takes a fresh approach to productivity. Having read their books, I found the conversation particularly engaging and highly recommend it.
Welcome to another edition of my weekly reading notes! This week's collection brings together some fascinating developments across the tech landscape. From the intricacies of building cross-platform .NET tools to impressive AI breakthroughs like Warp's stellar performance on SWE-bench, there's plenty to explore. I've also discovered some thought-provoking content about leadership, product management, and the art of meaningful communication. Whether you're interested in the latest AI tools, looking for career insights, or simply want to stay current with industry trends, this week's selection has something valuable for every developer and tech professional.
Programming
Using and authoring .NET tools (Andrew Lock) - Interesting post that shares the behind-the-scenes when you're building a tool for multiple targets and the challenge that it represents. Those also share the new ways of .NET 10
Design at GitHub with Diana Mounter (.NET Rocks!) - Very interesting, discussion about so many things: career, the balance between design and engineering, GitHub, and so much more.
How to Lead with Value with Dr. Morgan Depenbusch (How to Lead with Value with Dr. Morgan Depenbusch) - I really enjoyed this episode about the little things we can do to shift the way we interact with others.
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 wanted to kick the tires on the upcoming .NET 10 C# script experience and see how far I could get calling Reka’s Research LLM from a single file, no project scaffolding, no .csproj. This isn’t a benchmark; it’s a practical tour to compare ergonomics, setup, and the little gotchas you hit along the way. I’ll share what worked, what didn’t, and a few notes you might find useful if you try the same.
All the sample code (and a bit more) is here: reka-ai/api-examples-dotnet · csharp10-script. The scripts run a small “top 3 restaurants” prompt so you can validate everything quickly.
We’ll make the same request in three ways:
OpenAI SDK
Microsoft.Extensions.AI for OpenAI
Raw HttpClient
What you need
The C# "script" feature used below ships with the upcoming .NET 10 and is currently available in preview. If you prefer not to install a preview SDK, you can run everything inside the provided Dev Container or on GitHub Codespaces. I include a .devcontainer folder with everything set up in the repo.
Set up your API key
We are talking about APIs here, so of course, you need an API key. The good news is that it's free to sign up with Reka and get one! It's a 2-click process, more details in the repo. The API key is then stored in a .env file, and each script loads environment variables using DotNetEnv.Env.Load(), so your key is picked up automatically. I went this way instead of using dotnet user-secrets because I thought it would be the way it would be done in a CI/CD pipeline or a quick script.
Run the demos
From the csharp10-script folder, run any of these scripts. Each line is an alternative
dotnet run 1-try-reka-openai.cs
dotnet run 2-try-reka-ms-ext.cs
dotnet run 3-try-reka-http.cs
You should see a short list of restaurant suggestions.
OpenAI SDK with a custom endpoint
Reka's API is using the OpenAI format; therefore, I thought of using the NuGet package OpenAI. To reference a package in a script, you use the #:package [package name]@[package version] directive at the top of the file. Here is an example:
#:package OpenAI@2.3.0
// ...
var baseUrl = "http://api.reka.ai/v1";
var openAiClient = new OpenAIClient(new ApiKeyCredential(REKA_API_KEY), new OpenAIClientOptions
{
Endpoint = new Uri(baseUrl)
});
var client = openAiClient.GetChatClient("reka-flash-research");
string prompt = "Give me 3 nice, not crazy expensive, restaurants for a romantic dinner in Montreal";
var completion = await client.CompleteChatAsync(
new List<ChatMessage>
{
new UserChatMessage(prompt)
}
);
var generatedText = completion.Value.Content[0].Text;
Console.WriteLine($" Result: \n{generatedText}");
The rest of the code is more straightforward. You create a chat client, specify the Reka API URL, select the model, and then you send a prompt. And it works just as expected. However, not everything was perfect, but before I share more about that part, let's talk about Microsoft.Extensions.AI.
Microsoft Extensions AI for OpenAI
Another common way to use LLM in .NET is to use one ot the Microsoft.Extensions.AI NuGet package. In our case Microsoft.Extensions.AI.OpenAI was used.
#:package Microsoft.Extensions.AI.OpenAI@9.8.0-preview.1.25412.6
// ....
var baseUrl = "http://api.reka.ai/v1";
IChatClient client = new ChatClient("reka-flash-research", new ApiKeyCredential(REKA_API_KEY), new OpenAIClientOptions
{
Endpoint = new Uri(baseUrl)
}).AsIChatClient();
string prompt = "Give me 3 nice, not crazy expensive, restaurants for a romantic dinner in Montreal";
Console.WriteLine(await client.GetResponseAsync(prompt));
As you can see, the code is very similar. Create a chat client, set the URL, the model, and add your prompt, and it works just as well.
That's two ways to use Reka API with different SDKs, but maybe you would prefer to go "SDKless", let's see how to do that.
Raw HttpClient calling the REST API
Without any SDK to help, there is a bit more line of code to write, but it's still pretty straightforward. Let's see the code:
using var httpClient = new HttpClient();
var baseUrl = "http://api.reka.ai/v1/chat/completions";
var requestPayload = new
{
model = "reka-flash-research",
messages = new[]
{
new
{
role = "user",
content = "Give me 3 nice, not crazy expensive, restaurants for a romantic dinner in New York city"
}
}
};
using var request = new HttpRequestMessage(HttpMethod.Post, baseUrl);
request.Headers.Add("Authorization", $"Bearer {REKA_API_KEY}");
request.Content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");
var response = await httpClient.SendAsync(request);
var responseContent = await response.Content.ReadAsStringAsync();
var jsonDocument = JsonDocument.Parse(responseContent);
var contentString = jsonDocument.RootElement
.GetProperty("choices")[0]
.GetProperty("message")
.GetProperty("content")
.GetString();
Console.WriteLine(contentString);
So you create an HttpClient, prepare a request with the right headers and payload, send it, get the response, and parse the JSON to extract the text. In this case, you have to know the JSON structure of the response, but it follows the OpenAI format.
What did I learn from this experiment?
I used VS Code while trying the script functionality. One thing that surprised me was that I didn't get any IntelliSense or autocompletion. I try to disable the DevKit extension and change the setting for OmniSharp, but no luck. My guess is that because it's in preview, and it will work just fine in November 2025 when .NET 10 will be released.
In this light environment, I encountered some issues where, for some reason, I couldn't use an https endpoint, so I had to use http. In the raw httpClient script, I had some errors with the Reflection that wasn't available. It could be related to the preview or something else, I didn't investigate further.
For the most part, everything worked as expected. You can use C# code to quickly execute some tasks without any project scaffolding. It's a great way to try out the Reka API and see how it works.
What's Next?
While writing those scripts, I encountered multiple issues that aren't related to .NET but more about the SDKs when trying to do more advanced functionalities like optimization of the query and formatting the response output. Since it goes beyond the scope of this post, I will share my findings in a follow-up post. Stay tuned!
Here are my reading notes for the week: a mix of AI research and evaluation, .NET and Linux troubleshooting, testing framework changes, and JavaScript/TypeScript perspectives, plus a few podcast episodes on C#, work design, and software modernization that I found worthwhile.
AI
Introducing Research-Eval: A Benchmark for Search-Augmented LLMs (Reka Team) - One thing that has fascinated me since the beginning of this AI trend is how they test and measure the efficiency of those models. This post is going to go into details and share the benchmark (oss) and the results very interesting
Converting an xUnit test project to TUnit (Andrew Lock) - Like Andrew said in this post, changing your test framework is a big deal, but I will definitely consider TUnit for my next project. A very interesting post.
C# 14 with Dustin Campbell (.NET Rocks!) - Nice episode talking about C# and more precisely things that are related to Razor Pages. Always nice to listen to Carl and Richard.
How work design can reignite tremendous results (Modern Mentor) - Two Modern Mentor episodes this week, I love those shorter, concentrated episodes. This one focuses on ideas to help leaders redesign how work gets done.
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.
