An engineering framework for operational business applications

Business software,
engineered.

CodingWithEase turns business models into secure, consistent .NET applications through explicit architecture, deterministic generation, and verification that fails loudly.

See how it works Explore engineering

DeterministicPermission-awareAI-readyDiffable

One source of business truth

Write the domain.
The system builds the rails.

CodingWithEase keeps the application focused on entities, custom commands, queries, DTOs, and business-specific screens. The repeated infrastructure becomes a generated, inspectable contract.

Human + agent authored

Business model

Entities
Commands
Queries
Custom DTOs

Explicit tool

`cwe-gen`

Reads source, validates intent, emits deterministic code, then checks convergence.

Application rails

`I{Entity}Operations`

Server + browser implementations
Endpoints, handlers, permissions
Typed models and UI binding

Framework architecture

From business rules to a governed server–client application.

The business model remains the source of truth. cwe-gen turns it into repeatable infrastructure and one typed operations boundary, while engineers keep ownership of business behavior and custom UI.

CodingWithEase architecture showing authored business truth flowing through Roslyn and cwe-gen into server infrastructure and browser UI joined by I Entity Operations. — **System architecture**Open the diagram to inspect it at full resolution.

Authored business truthEngineer and coding agent work inside explicit conventions

Business rules Entities Commands Queries Custom DTOs

cwe-gen generation engineRoslyn SyntaxTree identifies types, members, and declared intent

Analyze source shapes Validate conventions Generate deterministic C# Verify convergence

03A

Generated rails

Server implementation

Slim endpoints and CQ handlers
Repositories and provider-neutral data access
Permission catalog and server enforcement
Validation, audit, documents, and errors
AI tool surface and integrations

The server is the security boundary.

Shared business boundary I{Entity}Operations

Typed DTOs
Explicit methods
Permission-aware results

Server⇄ClientHTTPS · typed contracts

03B

Generated consumption

Browser client

Typed HTTP operations implementation
Generated PageModels and UI binding
Reusable grids, forms, and components
Permission-aware navigation and actions
PWA shell and AI-assisted workflows

The UI maps to operations—not infrastructure.

InspectGenerated C# is readable, diffable, and debuggable.

EnforceAnalyzers, permissions, and composition rules guard boundaries.

ProveTests, regeneration checks, builds, and release smoke provide evidence.

Explore the engineering reference

Developer-ownedBusiness rules and query performance remain application engineering.

The framework provides secure rails, analyzers, paging, caching, and diagnostics. The developer defines correct domain behavior and proves query plans, indexes, payloads, and response times against realistic data.

One system, two perspectives

What quality means
depends on where you stand.

Readable generation

Real C# files live on disk. They are greppable, debuggable, diffable, and owned by a deterministic generator—not hidden behind compiler magic.

Stable boundaries

Browser-safe contracts, server-only runtime code, provider-neutral data access, and one dependency direction are enforced as architecture—not remembered as style.

Failure moved left

Invalid permissions, unresolved source shapes, stale generation, and composition mistakes become diagnostics before they can become expensive runtime mysteries.

Claims need enforcers

Quality is a system,
not a confidence level.

Every important promise is pushed toward executable proof. The goal is not to produce code that looks plausible; it is to make the wrong shape difficult to express and impossible to ship silently.

Engineering promiseMechanismWhat it prevents

Generated output is reproducible

Content comparison, ordinal ordering, cold-start generation, orphan cleanup, and a second-run fingerprint check.

“Works on my machine” output drift

Architecture stays intact

Dependency rules and package boundaries are checked by tests and release scripts across framework and generated consumers.

Convenient shortcuts becoming permanent coupling

UI structure is reviewable

The same composition rules run in Roslyn analyzers and through CheckComposition on demand.

Pages that compile but violate the application model

Packages are tested as consumers use them

The release ladder packs, installs tools, creates clean applications, generates twice, builds, tests, and performs a startup smoke.

A green monorepo hiding a broken package

Move failures left

Silent no-op→Runtime error→Compile error→Generation diagnostic→Structurally impossible

Read the evidence and responsibility boundary

Security is a complete chain

The handler is the boundary.

A hidden menu item improves the experience; it does not secure the data. CodingWithEase generates and carries each permission through five explicit links, with enforcement at the request handler and row-level scope as a separate axis.

Key

Generated from entity and verb

Catalog

Seeded into the grantable universe

Grant

Composed through roles and overrides

04 · SECURITY BOUNDARY

Enforce

Checked again inside the handler

Gate UI

Accurate UX, never the last defense

Default posture

Explicit, cataloged access

CRUD is not assumed public. Generated operations, endpoints, permission keys, and AI tools all derive from the same declared capability surface.

Data integrity

Server-authoritative audit

Audit values never ride the editable client model. They are stamped by the server in an ordered save pipeline.

Operations

Schema drift fails loudly

A model fingerprint detects a database that no longer matches the application and stops a silent, wrong-schema startup.

Defense in depth

Endpoints, handlers, scopes

Endpoint authorization, handler checks, save-time authorization, page gates, and page-scoped AI tools reinforce the same permission model.

Security boundarySecure by design does not mean invulnerable by definition.

CodingWithEase keeps generated permission, handler, operations, and save-pipeline infrastructure outside normal agent-authored code. Developers still own permission policy, row scope, business rules, custom code, dependencies, configuration, and adversarial testing.

Review responsibilities →

Two AI stories. Deliberately separate.

AI builds the app.
AI works inside the app.

A / DEVELOPMENT TIME

Agents work from version-true capabilities.

Instead of asking a coding agent to guess APIs from generic training data, dotnet-ai discovers capability providers from the built application. References are generated from the installed assemblies themselves.

Build before discovery, with a loud zero-provider diagnostic
Reflection-derived component and capability references
Architecture documents and approval gates before implementation
Composition checks shared with build-time analyzers
Feedback journals turn agent friction into framework improvements

RESULTAgent intelligence stays focused on business semantics—not framework archaeology.

B / APPLICATION RUNTIME

Users get an assistant that understands where they are.

Each generated app can expose an in-app text—and optionally voice—assistant. Its context follows the application’s real page structure, and its tools come from the same generated business operations.

Bounded, page-aware context instead of the entire application
Generated, strongly typed tools for queries and commands
Mutations available only when page declaration and permission agree
Customer-facing exposure controlled at compile time
Handler authorization remains the final security boundary

RESULTAI becomes an application capability—not an unbounded chat box bolted on later.

THE UI CONTRACT

// One contract. Two hosts. Same component.
@inject IEmployeeOperations Employees

// Server: direct operation
// Browser: typed HTTP operation
// Caller: does not need to know

The interface that removes a split

UI maps to operations,
not transport.

Every entity gets an I{Entity}Operations contract with the correct implementation registered in each host. A component can prerender on the server and continue in the browser without rewriting its data access.

One component modelServer and WebAssembly agree

One permission pathEvery operation reaches enforcement

One typed surfaceDTOs and results remain consistent

From a factory problem to a framework

An engineering journey,
not a one-week experiment.

The framework began with a practical question inside EMMo: how can recurring application code become faster to deliver, more consistent, and easier to trust? Each generation answered that question with evidence from the previous one.

01 · EMMo
The productivity problem appears in a real MES
While developing EMMo, Lucian saw that repositories, grid pages, forms, and other repeated structures could be standardized instead of rebuilt feature by feature.
02 · Reflection
A console generator proves the first idea
The first tool read DTOs through reflection and generated repositories and UI pages with grids and forms. It established the core principle: describe business data once, then derive the repeatable application surface.
03 · Compiler studies
From templates toward syntax understanding
During a second bachelor’s degree in computer science, compiler studies led to an attempt at a custom syntax analyzer. Research into the problem revealed Roslyn and C# source generators.
04 · BlazorForKids
Roslyn source generators meet Blazor Server
BlazorForKids became a broad experiment in generating domain, data, and UI code inside a Blazor Server application. It moved the idea from a helper tool toward a complete development system.
05 · SSR trials
Four legacy generations expose the limits
The move to Blazor SSR continued through CodingWithEase V1–V4. Those trials showed that compiler-hidden source-generator output was not the best contract for debugging, reviewing, versioning, or guiding AI coding agents.
06 · cwe-gen
Explicit generation, powered by Roslyn
Today, cwe-gen reads real source through Roslyn SyntaxTree, resolves types and methods, validates the model, and writes readable code to disk. The generated result is inspectable, diffable, deterministic, and verified.

THE CONTINUITY

EMMo supplied the operational pressure. Compiler study supplied the language tools. BlazorForKids and four SSR generations supplied the experiments. CodingWithEase turns those lessons into an enforceable delivery system.

Opinionated on purpose

A strong fit for
operational systems.

Designed for

Manufacturing and factory applications
Entity-heavy operational workflows
Role-gated work areas and administration
Dashboards, documents, catalogs, and audits
One engineering approach repeated consistently

Honest boundaries

Not a general-purpose UI toolkit
Convention is a contract, not a suggestion
Generated framework code is never hand-edited
Unusual requirements may need deeper framework knowledge
Consistency is chosen over unlimited escape hatches

From framework capability to company outcome

Need an internal app—or clarity before you build one?

CodingWithEase is the engineering platform behind work delivered through Elgibe Solutions. The engagement starts with the real process and business outcome, not with selling software as an isolated product.

ELGIBE SOLUTIONS · LUCIAN BUMB

Operations judgment and implementation capability in one engagement.

Lucian works with factories and operational companies to identify bottlenecks, prioritize change, define ownership and KPIs, translate needs into requirements, and guide disciplined implementation. When a custom .NET application is the right answer, CodingWithEase makes that implementation faster and more reliable.

Discuss a real process Explore Elgibe Solutions

Process analysis

Find bottlenecks, duplicated work, missing traceability, and the places where digitalization can create control.

Prioritization and roadmap

Put changes in the right order before investing in tools or automating a process that is not yet clear.

Governance, KPIs, and requirements

Define ownership, decision cadence, measurable outcomes, and pragmatic architecture for internal systems.

Implementation guidance

Keep process, scope, architecture, and delivery aligned—from the first operational question to a working application.

CodingWithEase

Business intent in.
Verified structure out.

For technical teams who want to inspect the architecture—and factory leaders who need confidence in what sits behind the screen.

Read the story behind CodingWithEase Back to top ↑

Business software,engineered.

Write the domain.The system builds the rails.

Business model

cwe-gen

I{Entity}Operations