Resource Center

When most engineering teams talk about "using AI in development," they mean a developer has GitHub Copilot installed. Suggestions appear as they type. Some are useful, some aren't. The developer accepts what looks right and moves on. That's AI-assisted coding. It's useful. It's also only one small piece of what AI-driven development actually is — and conflating the two is one of the most common mistakes teams make when trying to modernize their delivery process. An AI coding assistant operates at the level of a single engineer writing a single file. It autocompletes functions, suggests variable names, and sometimes generates a block of boilerplate. The engineer is still responsible for every decision — the tool just types faster. An AI-driven development environment operates at the level of the entire delivery system. It changes how work is specified, how it's designed, how it's tested, how it's deployed, and how production health is monitored. The engineer's role shifts from authoring every line to reviewing, validating, and directing AI-generated output within a system designed to catch problems automatically.

AI-Assisted Coding

Autocompletes code inside the IDE. Speeds up authoring. The delivery system around it is unchanged — manual processes, manual testing, manual deployment.

AI-Driven Development

Automates requirements, design, code generation, testing, CI/CD, UAT, and production monitoring. The entire delivery system is built to support and validate AI-generated output.

"A coding assistant accelerates one engineer writing one file. An AI-driven development environment automates the system of delivering software."

According to GitHub's 2024 State of the Octoverse, 97% of developers now use AI coding tools in some capacity. Adoption has become the norm. But adoption alone doesn't produce the results teams expect — and in many cases, it makes things worse. When AI coding tools are dropped into an existing delivery process without changing the system around them, the results are predictable:

Generated code reflects the inconsistencies of the existing codebase — at higher volume and faster pace
Defects that would have taken a human time to introduce now appear in bulk
Velocity increases short-term while technical debt accumulates invisibly
The codebase becomes harder to maintain, not easier

The challenge has shifted from whether to adopt AI to how to do it without accumulating technical debt, degrading maintainability, or losing architectural coherence. That shift requires thinking about AI as a delivery system problem — not a tooling problem. A true AI-driven development environment automates work across every phase of the software delivery lifecycle. Here's what that looks like in practice:

Structured checklist templates and AI-generated specs replace unstructured discovery sessions. Analysts produce precise, machine-readable requirements that feed directly into technical design — no translation layer, no information lost.

Architecture patterns decompose requirements into development tasks automatically. Design becomes repeatable rather than ad hoc — every feature follows the same structural logic, which is exactly what makes AI code generation reliable downstream.

LLMs generate implementation code and test scenarios directly from design specs. Engineers review, validate, and extend — they are no longer authoring from scratch. The quality of this output depends entirely on the quality of phases 1 and 2 feeding into it.

Fully automated pipelines handle build, multi-level testing, environment provisioning, UAT promotion, and production deployment. Every change — regardless of how fast it was generated — moves through the same quality gates before it reaches a customer.

Telemetry is analyzed on a defined cadence — hourly, daily, weekly. AI surfaces anomalies and generates improvement suggestions automatically. The system doesn't just deliver software; it watches what happens after delivery and feeds that signal back into the process.

If your team is currently using AI coding tools without this surrounding infrastructure, you have the first piece of a much larger system. The tools are not wrong — the context they're operating in is incomplete. The good news is that building the system is a structured process. It starts with establishing a consistent architectural foundation, adds automated quality gates and pipeline hardening, and then layers in AI-assisted generation on top of an environment designed to validate and deploy that output safely.

Want the Full Framework?

Clear Measure's AI-driven development methodology covers the complete lifecycle — from readiness assessment and architectural standardization through full pipeline automation and production telemetry. See the full technical guide →

The distinction between AI-assisted coding and AI-driven development isn't academic. It's the difference between a tool that speeds up one engineer and a system that transforms how an entire team delivers software. Understanding where you are on that spectrum is the first step toward building something better.

Talk to a Clear Measure AI DevOps Architect. We'll assess your codebase, DevOps foundation, and delivery baseline and tell you honestly what your AI readiness looks like. Talk to an Architect

Increase Speed

Blogs

Automate Expense Reports with .NET Agents & Azure AI

One of the most promising applications of generative AI in today’s enterprise landscape is automating business processes. These workflows often involve nuanced decisions and inconsistent or unstructured data, making them difficult to automate with traditional logic-based systems. In this post, we’ll explore how to build a .NET agent using Semantic Kernel and Azure AI Foundry to process employee expense reports based on natural-language policies. This is a practical, hands-on example of how large language models (LLMs) can be embedded into real business applications. To access the code, you can find it on github here.

Most organizations require employees to submit expense reports for reimbursement. These reports typically include:

A summary of expenses (meals, travel, lodging, etc.)
Receipts or supporting documents
Explanations or justifications

A human reviewer must then interpret the company’s expense policy to determine whether each report should be approved, denied, or escalated. Policies often contain natural-language rules like:

Meals must not exceed $75 per day
Receipts are required for expenses over $25
Travel must be pre-approved
Alcohol is not reimbursable

While these rules are easy for humans to understand, they’re tricky to encode in software. Legacy systems rely on structured input fields - dates, dropdowns, number boxes, etc. - to extract and validate data. These approaches struggle when inputs vary or include ambiguity. For example:

One user attaches a PDF receipt, another pastes in a screenshot
Justifications vary from bullet points to full paragraphs
Fields are left blank or inconsistently formatted

Maintaining and scaling these brittle rulesets is time-consuming and error-prone. What’s needed is a system that understands context and intent, not just structure. By combining Semantic Kernel with Azure-hosted language models, we can build a .NET agent that reads expense data, applies policy logic, and returns a clear recommendation - all using natural language. Benefits of this approach:

Works with inconsistent or unstructured input
Understands prose-style policies and nuanced reasoning
Returns human-readable summaries for transparency

We’ll start by defining a simple data structure to hold the agent’s recommendation.


public class ExpenseReportRecommendation
{
    public string EmployeeName { get; set; } = string.Empty;

    public DateTime ReportDate { get; set; }

    public decimal AmountReported { get; set; }

    public decimal ReceiptsTotal { get; set; }

    public string Recommendation { get; set; } = string.Empty;

    public string Summary { get; set; } = string.Empty;
}

The agent will use this class to report its findings - whether to approve, deny, or refer a report to a manager. Our agent will need access to two main tools:

A function to retrieve the employee’s expense report
A function to retrieve the current expense policy

Here’s the function to retrieve the report:


[KernelFunction(nameof(GetExpenseReport))]
[Description("Gets the expense report for an employee on the specified report date.")]
public JsonDocument? GetExpenseReport(string employeeName)
{
    var path = Path.Combine(AppContext.BaseDirectory, "Data", $"{employeeName}.json");
    if (!File.Exists(path))
    {
        return null;
    }
    var jsonContent = File.ReadAllText(path);
    var report = JsonDocument.Parse(jsonContent);
    return report;
}


[KernelFunction(nameof(GetExpensePolicyAsync))]
[Description("Gets the travel expense policy for the organization.")]
public async Task<string> GetExpensePolicyAsync()
{
    var fullPath = Path.Combine(AppContext.BaseDirectory, PolicyPath);
    var policy = await File.ReadAllTextAsync(fullPath);
    return policy.Trim();
}

And here's the function to load the policy:


[KernelFunction(nameof(GetExpensePolicyAsync))]
[Description("Gets the travel expense policy for the organization.")]
public async Task GetExpensePolicyAsync()
{
    var fullPath = Path.Combine(AppContext.BaseDirectory, PolicyPath);
    var policy = await File.ReadAllTextAsync(fullPath);
    return policy.Trim();
}

In a production environment, these could connect to a database, SharePoint site, or cloud storage. Now we create a ChatCompletionAgent, wiring in the tools and specifying how it should interpret the data. This includes system instructions and the output format.


var kernel = Kernel.CreateBuilder()
    .AddAzureOpenAIChatCompletion(deploymentName, endpoint, apiKey)
    .Build();

kernel.Plugins.AddFromType<ExpenseReportTools>(nameof(ExpenseReportTools));

_chatCompletionAgent = new ChatCompletionAgent
{
    Name = "Expense-Agent",
    Description = "Agent for expense report processing.",
    Instructions = $"""
You are a expense report processing agent.
Apply the organization's expense policy to recommend if expense reports should be approved, denied, or referred to a manager.
'Approve' means the total amount matches the receipts and is within policy limits and rules.
'Deny' means the total amount does not match the receipts, exceeds policy limits, or violates rules.
'Refer' means the expense report requires further review by a manager.
Return json with the schema:
{JsonSerializerOptions.Default.GetJsonSchemaAsNode(typeof(ExpenseReportRecommendation))}
""",
    Kernel = kernel,
    Arguments = new KernelArguments(
        new OpenAIPromptExecutionSettings
        {
            FunctionChoiceBehavior = FunctionChoiceBehavior.Required()
        })
};

We also define a method to invoke the agent and parse the result:


public async Task<ExpenseReportRecommendation?> ProcessExpenseReportAsync(string employeeName)
{
    var chatMessage = new ChatMessageContent(AuthorRole.User, $"Process the expense report: {employeeName}.");

    await foreach (ChatMessageContent chatMessageContent in _chatCompletionAgent.InvokeAsync(chatMessage))
    {
        var response = chatMessageContent.Content ?? string.Empty;

        if (!response.StartsWith("{"))
        {
            continue;
        }

        var expensesReportDecision = JsonSerializer.Deserialize<ExpenseReportRecommendation>(response);
        return expensesReportDecision;
    }

    throw new InvalidOperationException("Failed to process expense report");
}

This method sends a request to the agent and parses the returned JSON into our predefined class. Let's try it out by evaluating reports for two employees:


var expenseAgent = new Agent(deploymentName, endpoint, apiKey);

var employees = new[] { "Alex", "Sam" };

foreach (var employee in employees)
{
    var recommendation = await expenseAgent.ProcessExpenseReportAsync(employee);

    ArgumentNullException.ThrowIfNull(recommendation, nameof(ExpenseReportRecommendation));

    Console.WriteLine($"Recommendation for {employee}:");
    Console.WriteLine($"Employee Name: {recommendation.EmployeeName}");
    Console.WriteLine($"Report Date: {recommendation.ReportDate.ToShortDateString()}");
    Console.WriteLine($"Amount Reported: {recommendation.AmountReported:C}");
    Console.WriteLine($"Receipts Total: {recommendation.ReceiptsTotal:C}");
    Console.WriteLine($"Recommendation: {recommendation.Recommendation}");
    Console.WriteLine($"Summary: {recommendation.Summary}");
    Console.WriteLine("-------------------------------------------------------");
}

Console.WriteLine("Press any key to continue...");
Console.ReadKey();

In this example:

The agent recommends approving Alex's report.
Sam's report is denied due to a discrepancy between the total reported and the attached receipts.

Try modifying the policy to allow small discrepancies or relax other rules - and see how the agent adapts its reasoning accordingly. This isn't just automation - it's decision automation. The agent:

Reads semi-structured or natural language inputs
Interprets human policies
Produces explainable, auditable decisions

It shows how large language models can act as reasoning engines for enterprise workflows, delivering decisions that are both scalable and accurate - all within your .NET environment.

Octopus Deploy Migration Planning: How to Modernize Your Environment Without the Risk

AI-Driven Development vs. AI-Assisted Coding: What’s the Difference?

AI Software Delivering More Value in Less Time

Transforming Software Architecture and Delivery Utilizing AI

Automate Expense Reports with .NET Agents & Azure AI

RAG with SQL Server in .NET – Build Semantic Search with Azure AI

How to Use AI Right

AI Won’t Replace Developers—It’ll Make the Best Ones Even Better

Filters

Services

Technologies

Resource Center

The Five PIllars

Training Center

About Us