DADERA
DEENPL
AICB · AIContextBuilder

So that AI tools really understand your C# code.

AICB (AIContextBuilder) analyses a .NET solution with Roslyn – the way the compiler sees it – and makes the result available to coding agents and language models.

What AICB doesDownloads & documentation
From practice

Built for my own work.

I built AICB for my own daily work – which includes add-ons for SAP Business One, interfaces, EDI integrations and custom software. For SAP Business One it therefore ships with suitable presets: for layers, namespaces and the typical pitfalls of the DI API. It remains a general .NET tool.

AICB has no connection to SAP Business One and establishes none. It reads C# source – and an add-on is a C# project like any other. The SDK project format is a prerequisite. The presets in detail are described with the desktop app.

Semantic code analysis

Relationships, not text matches.

A text search finds strings. AICB does not just collect files or matches – it uses Roslyn to analyse how your C# code actually fits together, the way the compiler sees it.

  • Symbols
  • References
  • Implementations
  • Overrides
  • Call chains
  • Dependencies
  • Dependency injection
  • Tests
  • Side effects
  • XAML bindings

Who calls this?

A text search finds the name. It does not find the calls that go through an interface or a base class.

What breaks if I change it?

The direct hits are rarely the problem. AICB also names the callers of the callers.

What is redundant?

Dead code, dependency cycles and unused registrations appear nowhere in the source. They only emerge from the whole picture.

Where AICB does not know something for certain, it says so: an answer distinguishes “no callers” from “callers unknown” and shows whether a value comes from the code, from an AI tag or from an estimate.

One core, two ways

What AICB does

AICB reads a solution once and understands it as a whole: types, calls, dependencies, tests. You use this analysis in two ways – depending on whether an agent asks or you make the selection yourself.

For coding agents

MCP server & command line

Coding agents ask AICB directly about symbols, callers and the impact of a change – instead of searching the source. Single questions also work without an agent, via the command line.

Tested with Claude Code, Codex and OpenCode

To the MCP server →
For your own selection

Desktop app

A Windows application in which you decide which parts of a solution belong in a context document for a language model, and in how much detail – traceable and repeatable.

To the desktop app →

How it works – either way

  • Open a solution
  • Roslyn analyses it
  • Select or ask
  • Context document or answer

Both ways share one analysis and one configuration. What you set in the desktop app applies to the MCP server as well – and the other way round.

Use cases

For the hard questions.

AICB is not built for the quick one-off question, but for tasks where relationships across many files decide the outcome.

  • Impact analysis

    Before anything changes: who uses a symbol, directly and across several levels, which tests guard it and what the compiler will not report.

  • Refactoring

    Layers, dependency cycles, coupling and complexity – followed by a review with a verdict, including changes to the public API.

  • Debugging

    Deep call chains, the path from one method to another, side effects such as file or network access, and typical async pitfalls.

  • Understanding large codebases

    Architecture overview, entry points and the role of every type – for getting to grips with an unfamiliar or long-grown solution.

  • Tests and coverage

    Which tests cover a symbol, where coverage is missing and where complex code is untested.

  • Code quality

    Dead code, design weaknesses, calls into third-party libraries and compiler diagnostics without a full build.

Context under control

As much context as needed – not as much as possible.

The context is not fixed. You decide which code and which relationships go into it – so the model gets what is relevant rather than everything.

  • Configurable relationships

    Callers, callees, usages, inheritance, interface implementations, injected dependencies, created and used types, tests – each switchable, with adjustable expansion depth. Framework types, generated code or test classes can be left out.

  • Controlled size

    Token budget, detail level per node from the bare signature to the full source, adaptive reduction and an estimate of the document size before anything goes to the model.

  • Profiles for the task

    Built-in templates bundle a context strategy: General for everyday work, Refactoring with architecture, layers and quality metrics, Debugging with deep call chains, full detail and line numbers. Plus templates for feature work, onboarding, tests, documentation, performance and security – and matching tool profiles for agents.

  • XAML included

    WPF interfaces are read as well: which binding points to which property, which view uses a type, which binding leads nowhere. The XAML that belongs to the code goes into the context – interface and C# code are looked at together.

All settings in detail are described with the desktop app.

AI tags

What the code does not say, you tell the model right at the code.

Some things cannot be read reliably from the source alone: which business role a class plays, which layer it belongs to, which rule it protects. With AI tags you write this as a short block in the documentation comment – AICB takes it into the context.

  • Right at the code – in the familiar /// comment, versioned with the source
  • Meaning instead of guesswork – role, layer, domain, responsibility, side effects, stability and more
  • Precedence over estimates – an AI tag beats the automatic inference; none switches a wrong inference off
  • What matters stays in – methods marked priority="high" are kept when the context is reduced
  • For agents, too – the MCP server searches by tagged roles and layers and shows which value came from the developer
/// <summary>Calculates prices for framework contracts.</summary>
/// <ai>
/// role="DomainService"
/// layer="Application"
/// domain="Pricing"
/// responsibility="Contract price before list price"
/// sideEffects="none"
/// </ai>
public class ContractPricingService
Status and outlook

Steered by hand today – multi-stage next.

Today you apply templates manually: you put the context together, check it and send it. Two further run types already exist in AICB but are not released yet.

Iterations planned

Multi-stage, automated runs across many places – one step per class or method. For example to generate, check and evolve AI tags.

Preselection planned

The model first receives a compact overview of the solution and preselects the relevant context; only then does the actual task follow. This makes AICB a steerable harness between developer, codebase and language model – with the human in control.

Supported projects

From .NET Framework to .NET 10

AICB loads C# projects in the SDK project format. This has been verified on public open-source solutions with these target frameworks:

  • .NET Framework4.6.2 · 4.7.2 · 4.8.1in the SDK project format
  • .NET Standard2.0 · 2.1libraries for several platforms
  • .NET6 · 8 · 9 · 10including Windows targets such as WPF
  • Solutions – as .sln, .slnx or .slnf solution filter
  • Large solutions, too – verified among others on dotnet/roslyn with 406 projects
  • Several target frameworks per project – recognised; optionally only the newest is analysed
  • Language version – up to and including C# 14
  • .NET SDK or Visual Studio – matching the targets of the solution, packages restored
  • Desktop app – on Windows
  • MCP server and command line – not tied to Windows

Projects in the older, classic project format – still common in many .NET Framework applications – are not listed as supported. If a solution contains such projects, the rest of it can be analysed through a solution filter.

Local and data-minimal

What stays on your machine.

AICB works locally and sends nothing outside on its own. The only connection the desktop app makes is to a language model – and only when you trigger it.

  • No telemetry – no usage reporting, no update check, no crash reports
  • No licence server – no activation, no online check
  • No network traffic – the MCP server and the command line send nothing outside
  • Language model only on request – a locally running model is an option
Availability

Downloads and documentation

Here you will find where AICB is published and the detailed documentation to download.

Where to get it

AICB is published on the following platforms:

The release contains the Windows installer, a portable ZIP and the MCP server as a .NET package. A nuget.org listing of the MCP server follows shortly; until then it installs from the downloaded package file.

Documentation (PDF)

The complete description of AICB: every screen with screenshots, all functions and detailed explanations.

The detailed documentation is in progress and will be available for download here once it is finished.

Licence

Free up to a certain size.

The licence follows the size of your organisation, not the feature set. Use is free as long as your organisation reaches none of these three thresholds:

  • 100 employees – counted across the group of companies
  • EUR 10 million annual turnover
  • 21 developers

For natural persons – private, hobby and educational use – and for educational institutions in teaching and non-commercial research, use is free regardless of those thresholds. Only your own organisation is counted: the size of your clients does not matter, not even when working on their premises. Once a threshold is reached, a commercial licence is required; terms are agreed individually.

The feature set is the same in every case: there is no cut-down free edition and no technical enforcement. What governs is the licence text shipped with the software.

Questions about AICB?

About using it in your team, the commercial licence or your project – tell me briefly what you work with.

Send an enquiryMCP serverDesktop app