How It Works

From a natural-language brief to a Project Analysis plan, per-module DBML, generated microservices, GitHub repositories, and Cloud Run deployments — step by step.

Get started

Project with AI in QuickCode Studio — Project with AI

Project analysis running in QuickCode Studio — Analysis running

Describe your business requirements to AI

Start on the homepage with Try generating with AI, or open QuickCode Studio and choose Project with AI. Describe your product in natural language (optionally attach a PDF). Pick Google Gemini, OpenAI, or Anthropic Claude. QuickCode runs a Project Analysis first — a module plan you can review — then generates DBML per module.

Google Gemini

OpenAI

Anthropic Claude

Do not generate Identity/User modules

QuickCode injects IdentityModule automatically. Do not add separate user, role, or auth modules in AI output or DBML, they conflict with the built-in module.

Platform modules from the catalog

When email, SMS, or similar capabilities fit, analysis can select ready-made PLATFORM modules from the QuickCode catalog instead of inventing duplicate services.

Plan with AI

Answering an open question — Open question

Review the Project Analysis plan

Analysis returns a structured module plan: custom GENERATED modules, ready-made PLATFORM modules, and system Identity. Open questions highlight decisions that would change the schema. Answer only what you need — answering switches the flow to update the plan before DBML generation.

Open questions (optional)

Tap a question, pick a suggested answer or write your own, then update the plan. Questions are capped to the highest-priority gaps so you are not blocked by a long questionnaire.

Add a note

Optional context (providers, v1 scope, constraints) is kept with your answers and applied when you update the plan — PDFs are not resent on refine.

Generate only when the plan is ready

With unanswered questions, Generate DBML from this plan stays available. Once you keep an answer, the primary action becomes Update plan with answers until the analysis is refreshed.

Generate DBML schemas from the plan

When the plan looks right, generate per-module DBML in the background. Each GENERATED module gets tables, relations, and QuickCode DSL notes; PLATFORM modules are copied from the catalog. Review the result in QuickCode Studio, then iterate or deploy.

Per-module generation

Schemas are written and validated module by module. Failures stay isolated so successful modules are not regenerated.

Single-module AI still available

Use Module with AI or Update Module when you only need one bounded context, without running a full project analysis.

QuickCode AI panel answering a schema request with an Edit DBML action button — Ask AI handoff

QuickCode AI in Studio

QuickCode AI works with you across the whole project: it explains what you already have, and it writes schema changes when you ask for them. Understanding and changing stay in separate places on purpose. The QuickCode AI panel answers questions and never touches your DBML, while Edit DBML with AI applies schema changes for the selected module and always ends in a review step. When a question turns out to need a schema change, the answer carries a ready-to-run instruction into the right place for you.

QuickCode AI (read-only)

Ask about module boundaries, which tables hold which data, why a module was split the way it was, or how a QuickCode feature works. Answers are grounded in your own project, and nothing is written to your DBML.

Context is selected per question

A lightweight router reads the question first and pulls only the slices it needs: the Project Analysis context (domains, capabilities, processes, business rules, open questions), the architecture view (per-module pattern such as CQRS with Mediator or Service, database type, module template), the module context of up to three modules, and the saved DBML of those modules for real table, column, relation, and QuickCode DSL detail. Platform questions load the QuickCode knowledge topics instead.

Every answer shows its sources

Each reply lists the context it was built from as small source chips, module-scoped ones named after the module. Recent turns of the conversation stay in scope, so follow-up questions do not need to repeat the setup.

Edit DBML with AI

Describe a schema change for the selected module. The panel keeps prompt history and a token counter, and the result is always previewed before it becomes part of the module.

Handoff instead of guessing

A schema request typed into the right panel selects the target module, expands your wording into a concrete table and column instruction, and focuses the left panel so you continue in the normal review and approval flow.

Minimal change contract

The refine prompt holds the model to the scope you asked for. Add one table and every other table stays byte-for-byte identical; ask for a column across all tables and it still applies everywhere.

Review the schema diff

Results open on a line-by-line diff of added and removed DBML lines, next to a summary tab with the provider, model, and token usage. Save the module when the diff looks right.

Get started

Why QuickCode is Different

Copilot and ChatGPT help you write code. QuickCode helps you run engineering at scale, with repeatable architecture, safe regeneration, and working APIs from day one.

Regen-Safe Generation

Generated code lives in .g.cs files; your logic stays in partial classes. Regenerate after schema changes without manual merges.

Consistent Architecture

Every service follows the same patterns for logging, validation, auth, and CI/CD.

Early Schema Validation

Invalid DBML is caught before generation with per-module errors.

Design your schema

ERD and table details with DSL — DBML editor & ERD

DBML & QuickCode DSL

Edit tables, enums, and Ref relationships in the QuickCode Studio DBML editor or diagram view. Default CRUD is generated for every table; add QuickCode DSL in table Note blocks for custom queries, updates, and deletes.

Modules & templates

Add modules from templates (e-commerce, HR, email, and more) or generate with AI. Each module has its own DBML file and deployable API service.

Per-module settings

Set database type (PostgreSQL, MySQL, SQL Server) and architecture (CQRS + Mediator or Service) in the Project {} block or module settings.

Built for Iteration

Update DBML and regenerate. The generated layer refreshes; custom code in partial classes is preserved. Schema diff drives migration scripts and API updates consistently.

Generated layer

Controllers, DTOs, repositories, and scaffolding in .g.cs files; regenerated on each run.

Custom layer

Business logic, extra endpoints, and validation in partial classes QuickCode never overwrites.

What gets generated

Gateway Swagger and module APIs — Gateway APIs

APIs with Dapper & .NET 10

QuickCode generates .NET 10 API services with Dapper repositories, parameterized SQL for PostgreSQL, MySQL, or SQL Server. Choose CQRS + Mediator or Service pattern per module.

.NET 10

Docker

QuickCode DSL

Custom operations in DBML Notes compile to REST endpoints, handlers, and Dapper queries.

Postman collections

Auto-generated collections per module with auth environments for local, Docker, and Cloud Run.

Portal Live Report results grid — Report results

Live Report Print and export modal with PDF preview — Print & export

Print and export column selection, widths, and reorder — Columns & layout

Admin Portal & Identity

An admin portal is generated as MVC source code in your project — not a hosted QuickCode SaaS panel. It includes CRUD for your tables, Live Reports from DSL Query operations (including Print & export with column layout and PDF/CSV), group-based authorization, table-level permissions, and configurable endpoint workflows. Declare BLOB_IMAGE, BLOB_PDF, BLOB_VIDEO, and BLOB_FILE columns in DBML to get upload fields, list actions, and in-app preview (image lightbox, PDF iframe, HTML5 video). Files are stored as HTTPS object URLs (Azure Blob, S3-compatible storage such as Cloudflare R2, or local files in development), not binary in the database. IdentityModule handles users, roles, and API/portal access; do not duplicate it in your modules.

Table management

Manage records through auto-generated portal screens tied to your DBML tables.

Access control

API method grants and portal page permissions from centralized management screens.

File and media columns

Use BLOB_IMAGE for photos and logos, BLOB_PDF for datasheets, BLOB_VIDEO for product or intro videos, and BLOB_FILE for other documents. The portal generates upload controls, size limits, and Preview actions without custom UI code.

Object storage backends

Configure Azure Blob Storage, any S3-compatible provider (including Cloudflare R2), or local file storage for development. The same pipeline applies to all BLOB_* column types.

Live Reports

DSL Query operations appear in the portal as Live Reports. Set parameters, click Run Report, and scan the result grid — the matching GET API path is shown on the page. Use Print & export to choose columns, set % widths, reorder fields, then download PDF/CSV or print with a live page preview.

Microservices Architecture

Each domain module is a separate deployable API. YARP gateway routes client requests; an event listener service handles async processing where configured.

Gateway with YARP

Single HTTPS entry point to module APIs with routing and security.

Module APIs

Independent services per module, each with Swagger and Cloud Run deployment.

Deploy & integrate

GitHub Repository & Actions

All generated code is pushed to github.com/QuickCodeStudio/{project-name}. GitHub Actions run tests, build Docker images, and trigger deployment workflows.

GitHub

QuickCode

Automated testing

Generated test suites for repositories and CRUD operations are included in the repo.

QuickCode Studio generation pipeline complete — Pipeline complete

GitHub Actions pipeline — GitHub Actions

Deploy to Google Cloud Run

After you confirm Generate Microservices, QuickCode Studio tracks the full cloud pipeline: GitHub repo, code push, Google Cloud project, solution generation, migrations, then build and deploy for portal, gateway, listener, and each module API. URLs follow patterns like {project}-gateway.quickcode.net and {project}-portal.quickcode.net.

Cloud Run

Live pipeline in QuickCode Studio

Watch setup, generation, and Cloud Run deploy status in real time — mid-run progress and the completed view with service links.

Regenerate safely

Re-run Project with AI or Generate Microservices when the plan changes. Confirm before existing modules are replaced.

Run Locally with Docker

docker-compose in the generated repo runs the full stack locally (gateway, portal, module APIs, and databases) for development and demos before Cloud Run.

Try it

Ask Your Project

After analysis and generation, ask questions about architecture, modules, the data model, business rules, and APIs. QuickCode AI answers from the project structured context — Project SOT, module SOTs, dependencies, DBML, DSL, and generated APIs — not generic assumptions. QuickCode does not just generate your project. It understands it.

Not a generic chatbot

Each answer is grounded in your project: which modules exist, how they depend on each other, the saved DBML, QuickCode DSL rules, and the APIs those schemas produce.

Example questions

Which modules are affected if I change this table? How does authentication flow through this project? Where is customer status used? Which APIs depend on this module?

QuickCode Studio workspace — QuickCode Studio

QuickCode Studio & Demo

Use QuickCode Studio for Project Analysis, DBML editing, ERD visualization, module AI, and the live Cloud Run generation pipeline. Explore the public demo (gateway, portal, GitHub) from the Demo menu, or start a new project from the homepage.

QuickCode Studio

https://studio.quickcode.net — projects, Project with AI analysis, per-module DBML, AI refine, and cloud generation progress.

Demo project

Live demo gateway and portal; see /demo-project for a guided walkthrough with credentials.

AI Rule Pack (Persistent)

Every generated project includes AI-readable guide files so code generation follows consistent project rules from the first prompt to the latest regeneration.

What is added: rule and guide files such as AGENTS.md and AI instruction files.
How AI uses it: the generator and AI assistants read these files before creating or updating code.
Why it is safe: regeneration preserves these files, so your generation behavior stays stable over time.