DEV Community: Salah

Don't use IA only to code faster

Salah — Mon, 09 Mar 2026 10:33:57 +0000

Most .NET developers use AI to write code faster. The ones moving ahead use it to design better.

In my experience, writing the actual C# logic is rarely the bottleneck. The real delays on a project happen in the "gaps" between coding.

Here is where the time actually goes:

The Setup (The "File > New" Tax)

Spending 2 hours configuring a new Microservice or Web API.
Setting up Dependency Injection.
Adding Middleware and Logging.
Configuring Docker and CI/CD pipelines.

The AI Fix: Use custom "System Prompts" to generate a full .NET 9 skeleton that follows your team's specific standards in seconds.

The Wait (The PR Black Hole)

Sending a Pull Request and waiting 3 days for a reviewer to catch a simple syntax error or a naming convention mistake.

The AI Fix: Run an LLM-based "Pre-Review" on your own branch. It can catch the "obvious" mistakes before a human even sees them. This keeps your Senior Devs focused on logic, not typos.

The Missing Docs (The "Legacy" Trap)

Shipping a feature with zero documentation. The next developer (or you, 6 months from now) spends a day just trying to understand the data flow.

The AI Fix: Feed your final classes into an AI to generate a Markdown README or a Mermaid.js sequence diagram. It’s a 30-second task that saves hours of future debugging.

The Hard Truth:
If you only use GitHub Copilot to autocomplete a foreach loop, you are only fixing 20% of the problem.

The real "Senior" move is using AI to automate the friction, so you can spend your energy on Architecture.

Where does your dev day feel the most wasteful? For me, it’s always the repetitive setup of new services.

What I Built: The "Claude Code" of Finance

Salah — Mon, 02 Mar 2026 15:02:00 +0000

This is a submission for the Built with Google Gemini: Writing Challenge

I built FinAgent.NET, an autonomous financial research agent. The goal was simple yet ambitious: create a tool that doesn't just "chat," but thinks, plans, and learns while investigating market data.

The Problem: Financial research is often fragmented. Analysts jump between news terminals, stock price APIs, and SEC filings. It’s manual, slow, and prone to oversight.

The Solution: FinAgent.NET acts as a digital quantitative analyst. You give it a complex prompt "Analyze the impact of interest rate changes on tech stocks over the last quarter" and it handles the rest.

AI's Role: Using the Microsoft Agent Framework and Google Gemini via Microsoft.Extensions.AI, the AI operates in a Self-Correction Loop. It creates a plan, executes tool calls to fetch real-time market data, and then reflects on its own findings. If the data is incomplete, it goes back into the loop until the research is solid.

🔍 What I Built: The "Claude Code" of Finance

I built FinAgent.NET, an autonomous financial research agent. The goal was simple yet ambitious: create a tool that doesn't just "chat," but thinks, plans, and learns while investigating market data.

The Problem: Financial research is often fragmented. Analysts jump between news terminals, stock price APIs, and SEC filings. It’s manual, slow, and prone to oversight.

The Solution: FinAgent.NET acts as a digital quantitative analyst. You give it a complex prompt—"Analyze the impact of interest rate changes on tech stocks over the last quarter"—and it handles the rest.

AI's Role: Using the Microsoft Agent Framework and Google Gemini via Microsoft.Extensions.AI, the AI operates in a Self-Correction Loop. It creates a plan, executes tool calls to fetch real-time market data, and then reflects on its own findings. If the data is incomplete, it goes back into the loop until the research is solid.

🧠 What I Learned: Beyond the Code

Building this project wasn't just about syntax; it was about architectural philosophy.

Agnosticism is Power: By using Microsoft.Extensions.AI, I learned how to build a system that is model-agnostic. Switching from a cloud-based LLM to a local model via Ollama became a configuration change rather than a code rewrite.

The "Single Agent" Realization: One of the biggest technical pivots was moving away from a complex multi-agent system (three separate agents talking) to a Single Agent State Machine. I realized that for a research loop, keeping the context in a single, well-managed ChatHistory is significantly cleaner and more reliable.

Soft Skills in "AI Negotiation": I learned how to treat the AI as a collaborator. Correcting the AI's initial over-engineered design for the agent loop taught me that a builder's intuition is still the ultimate compass.

💬 Google Gemini Feedback: The Good, The Bad, and The Ugly

The Good

Contextual Speed: Gemini was incredibly fast at parsing the GitHub repositories for examples and translating those Python concepts into a .NET-friendly architecture.

Structure: The ability to generate complex, ready-to-use plan.md files for other AI dev tools (like Cursor or Cline) acted as a massive force multiplier.

The Bad

Framework Friction: Occasionally, the AI leaned toward older Semantic Kernel patterns when I explicitly asked for the newer Microsoft Agent Framework. It required a few "pokes" to stay updated with the latest documentation.

The Ugly

Architectural Hallucinations: In the beginning, Gemini pushed for a "Group Chat" multi-agent design because that's a common framework trope. It took a firm human intervention to realize that for this specific use case, a single-loop design was superior. It’s a reminder that AI is a co-pilot, not the captain.

🚀 Where I’m Headed Next

The foundation of FinAgent.NET is solid. My next steps involve:

Real-time Streaming: Implementing SignalR to stream the agent's "thoughts" to a dashboard in real-time.

Persistent Memory: Giving the agent a vector database so it "remembers" previous market analyses to improve its future planning.

FinAgent.NET is proof that with the right tools and a bit of grit, we can build C# systems that don't just process data—they understand it.

C# Optimizations That Boosted Our Application's Performance

Salah — Tue, 26 Nov 2024 11:16:09 +0000

In the world of software development, performance is often the difference between success and failure. As an experienced developer, I faced a significant challenge when our C# application began to struggle under heavy load. After debugging and optimization, my team and I managed to give a good boost to the application's performance.
In this article, I'll share some easy key optimizations that made this possible, along with some practical examples and explanations.

Choosing the Right Data Structures

One of the most significant performance bottlenecks in any application is the choice of data structures. In C#, the right data structure can make all the difference. In some high-performance critical scenarios we can for example use Span

Example: Using Span Instead of Arrays

Before

public void ProcessData(byte[] data)
{
    for (int i = 0; i < data.Length; i++)
    {
        // Process each byte
    }
}

After

public void ProcessData(Span<byte> data)
{
    foreach (byte b in data)
    {
        // Process each byte
    }
}

Explanation:

Span is a stack-allocated struct that provides a memory-safe way to work with contiguous blocks of data (Span is not supposed to replace arrays).
By avoiding the overhead of array bounds checking and unnecessary memory allocations, Span can significantly improve performance, especially in tight loops.

Minimizing Garbage Collection Pressure

Garbage collection (GC) is a powerful feature of .NET, but it can introduce significant overhead if not managed properly. In some scenarios when the class is expensive to create or destroy, we can create an object pool by using a ConcurrentBag.
Example: Object Pooling

Before:

public void ProcessMessages()
{
    while (true)
    {
        var message = new Message();
        // Process message
    }
}

After:

public void ProcessMessages()
{
    var pool = new ObjectPool<Message>(() => new Message());
    while (true)
    {
        var message = pool.Get();
        // Process message
        pool.Return(message);
    }
}

Explanation:

In C# Object Pooling reuses objects instead of creating new ones, reducing the frequency of garbage collection.
We avoid the overhead of constant allocations and deallocations by reusing Message objects.

Algorithmic Optimizations

Sometimes, the biggest performance gains come from rethinking your algorithms.

Example: Replacing Linear Search with Binary Search

Before:

public bool Contains(List<int> list, int value)
{
    foreach (var item in list)
    {
        if (item == value)
            return true;
    }
    return false;
}

After:

public bool Contains(List<int> list, int value)
{
    list.Sort();
    return list.BinarySearch(value) >= 0;
}

Explanation:

List.BinarySearch(T) Method uses a binary search algorithm to locate a specific element in the sorted List or a portion of it.
Binary Search has a time complexity of O(log n), whereas linear search is O(n).
By sorting the list once and using binary search, we significantly reduce the time complexity for multiple searches.

Leveraging Parallel Processing

Modern CPUs have multiple cores, and C# provides powerful tools to take advantage of them.

Example: Parallel LINQ (PLINQ)

Before:

var results = data.Select(x => Process(x)).ToList();

After:

var results = data.AsParallel().Select(x => Process(x)).ToList();

Explanation:

PLINQ automatically parallelizes LINQ queries, distributing the workload across multiple cores.
This can lead to significant performance improvements for CPU-bound operations.

Caching and Avoiding Redundant Computations

Caching is a powerful technique to avoid redundant computations.

Example: Memoization with Dictionary Cache

Before:

public int Fibonacci(int n)
{
    if (n <= 1)
        return n;
    return Fibonacci(n - 1) + Fibonacci(n - 2);
}

After:

private Dictionary<int, int> cache = new Dictionary<int, int>();
public int Fibonacci(int n)
{
    if (n <= 1)
        return n;
    if (cache.ContainsKey(n))
        return cache[n];
    var result = Fibonacci(n - 1) + Fibonacci(n - 2);
    cache[n] = result;
    return result;
}

Explanation:

Memoization stores the results of expensive function calls and returns the cached result when the same inputs occur again.
By caching Fibonacci numbers, we reduce the time complexity from exponential to linear.

Avoiding Unnecessary I/O Operations

I/O operations, such as file access or network calls, are often the biggest bottlenecks in an application.

Example: Minimizing Database Calls

Before:

for (int i = 0; i < ids.Length; i++)
{
    var user = GetUserFromDatabase(ids[i]);
    // Process user
}

After:

var users = GetUsersFromDatabase(ids);
foreach (var user in users)
{
    // Process user
}

Explanation:

Batching database calls reduces the number of round trips to the database, significantly improving performance.
By fetching all users in a single call, we minimize the I/O overhead.

Using Structs Instead of Classes for Small Data Types

Value types (structs) are stored on the stack, which can be more efficient than reference types (classes) stored on the heap.

Example: Using Structs for Small Data

Before:

public class Point
{
    public int X { get; set; }
    public int Y { get; set; }
}

After:

public struct Point
{
    public int X;
    public int Y;
}

Explanation:

Structs are value types and are allocated on the stack, which is faster and uses less memory for small data types.
By converting Point to a struct, we reduce the overhead of object creation and garbage collection.

Profiling and Benchmarking

Before making any optimizations, it's crucial to identify the actual bottlenecks in your application.

Example: Using Benchmark.NET

[MemoryDiagnoser]
public class MyBenchmarks
{
    [Benchmark]
    public void MyMethod()
    {
        // Code to be benchmarked
    }
}

Explanation:

Benchmark.NET is a powerful tool for measuring the performance of your code.
By diagnosing memory usage and execution time, you can pinpoint the areas that need optimization.

Conclusion

As a developer, you can boost the performance of your C# application by applying the right strategies. In this article, I explained how it's important to always try to choose the right data structure, to use wisely parallel processing, and to avoid doing redundant computations. Optimization is not just about making code run faster, it's about making intelligent decisions that balance performance, readability, and maintainability.