Engineering reference · 02

AI can propose.
The framework must prove.

CodingWithEase does not make a model infallible. It makes the model work through version-true capabilities, deterministic generators, analyzers, server-enforced rules, and repeatable verification. Confidence is replaced by evidence.

Capability truthCanonical outputExecutable checks

Agent terminalDiscover before authoring

$ cwe guide
$ dotnet build
$ dotnet-ai init
$ dotnet-ai list
$ dotnet-ai execute <capability>
$ dotnet cwe-gen
$ dotnet-ai execute CheckComposition

ResultReadable C# + evidence

00 · THE DIFFERENCE

From probabilistic suggestion to governed implementation.

The agent still interprets business intent. It does not invent framework syntax from stale examples or repeatedly hand-code infrastructure already owned by the toolchain.

AI-assisted development flow from business intent through capability discovery, deterministic generation, analyzers, and release evidence. — **Governed AI delivery**Version truth and executable checks constrain probabilistic suggestions.

Unbounded AI coding

User → model → documentation fragments → plausible code. The result may compile while violating architecture, authorization, localization, or component composition.

CodingWithEase

User → model → discovered capability → canonical framework output. Generated code and analyzers turn the framework version itself into the authority.

Not “AI slop”

The claim is not that every generated feature is automatically correct. The claim is that AI output must enter an engineering system where mechanics converge, unsafe shapes are rejected, security is rechecked, and verification is reproducible.

01 · OPERATING SEQUENCE

The agent follows a repeatable engineering loop.

Building first ensures capability discovery reflects the actual referenced assemblies. Regeneration and composition checks then expose drift rather than hiding it.

01cwe guide

Read the framework-owned workflow.

02dotnet build

Produce version-true assemblies.

03dotnet-ai init

Discover the installed capabilities.

04dotnet-ai execute

Ask a capability for canonical output.

05dotnet cwe-gen

Generate visible infrastructure.

06build · test · CheckComposition

Turn claims into evidence.

02 · CAPABILITY LAYER

The framework answers framework questions.

Capability providers expose current components, generators, documents, context, and design rules directly from the installed version. The model composes within that discovered surface.

Components

Exact component names, parameters, examples, and composition constraints.

Data

Charts

Supported chart contracts and valid data shapes instead of guessed APIs.

Visual

Diagrams

Known diagram capabilities and framework-consistent output.

Code

Generators

Canonical scaffolding for entities, pages, commands, queries, and infrastructure.

Office

Documents

Framework-supported document creation and processing surfaces.

Knowledge

Document RAG

Application-aware retrieval instead of unconstrained context stuffing.

Context

AI context

Guide, discover, and eager tiers provide only the context the task needs.

System

Design rules

Shared visual and composition contracts keep generated interfaces coherent.

03 · ANALYZERS

Plausible-but-wrong code is a build problem.

Roslyn diagnostics and composition analysis catch failure modes that a model, reviewer, or successful compiler can otherwise miss.

Rule	What it rejects	Why it matters
CWE0204	An invalid connected-component parameter.	Stops hallucinated APIs at build time.
CWE0205	Synchronous `SaveChanges` paths that bypass the governed async pipeline.	Protects validation, authorization, and audit behavior.
CWE0209	User-facing text outside localization.	Prevents a new page from silently becoming single-language.
CWE0213	Authorization embedded inside a cached query.	Prevents cache hits from skipping the security decision.
CWE0214	Unknown PascalCase Razor tags.	Stops misspelled components becoming inert custom HTML.
CWE0324	Raw `HttpClient` in application structure.	Preserves operations, scoping, and security boundaries.

04 · DETERMINISM

AI supplies semantics. The toolchain owns mechanics.

Deterministic here means repeated infrastructure comes from pinned inputs and real generators—not that a language model produces identical prose on every run.

Version truth

Capabilities come from the build

The agent queries the referenced framework version, avoiding documentation drift.

Visible output

Generated code is real C#

It can be read, searched, diffed, debugged, and reviewed like authored code.

Convergence

Second generation is clean

The same semantic inputs must not keep rewriting tracked output.

Boundaries

Framework/ is not hand-edited

Fixes occur in source intent or the generator, so every consumer receives the correction.

Rejection

Analyzers constrain composition

Convenient shortcuts become explicit diagnostics instead of permanent architecture.

Evidence

CI repeats the proof

Build, tests, generation, composition analysis, and clean-tree checks are rerunnable.

05 · RUNTIME AI

The shipped app gives AI less authority than the user.

Development-time capabilities help an agent build the app. Runtime AI is a separate, permission-aware integration surface inside the finished application.

Reachability

Page-scoped tools

Only tools reachable from the current page enter the registry.

Authorization

Permission-filtered actions

Mutations require the page upper bound and the caller’s live permission; handlers check again.

Records

Governed search

Searchable entities automatically require their generated View permission.