A backend repository generated by @autobe.

This backend program was automatically generated using @autobe, the AI vibe coding agent for backend servers of below stack.

• TypeScript
• NestJS / Nestia
• Prisma
• Postgres

flowchart
subgraph "Backend Coding Agent"
  coder("Facade Controller")
end
subgraph "Functional Agents"
  coder --"Requirements Analysis"--> analyze("✅ Analyze")
  coder --"ERD"--> database("✅ Database")
  coder --"API Design"--> interface("✅ Interface")
  coder --"Test Codes" --> test("✅ Test")
  coder --"Main Program" --> realize("✅ Realize")
end
subgraph "Compiler Feedback"
  database --"validates" --> prismaCompiler("Prisma Compiler")
  interface --"validates" --> openapiValidator("OpenAPI Validator")
  interface --"generates" --> tsCompiler("TypeScript Compiler")
  test --"validates" --> tsCompiler("TypeScript Compiler")
  realize --"validates" --> tsCompiler("TypeScript Compiler")
end

Also, this backend application was built following @autobe's waterfall development model, where each specialized AI agent handles a specific phase of development. The process ensures 100% working code through continuous compiler feedback and validation at every stage.

Each agent receives input from previous phases and produces validated output that becomes the foundation for the next development stage. The Facade Controller orchestrates the entire process, while Functional Agents handle specialized tasks with built-in Compiler Feedback ensuring code quality and correctness.

Below table shows the mapping between waterfall phases, corresponding @autobe agents, and the actual deliverables you can find in this repository:

This template project has categorized directories like below.

As you can see from the below, all of the Backend source files are placed into the src directory. When you build the TypeScript source files, compiled files would be placed into the lib directory following the tsconfig.json configuration. Otherwise you build client SDK library for npm publishing and their compiled files would be placed into the packages directory.

• packages/api/: SDK module built by npm run build:api
• docs/: Documentation directory
  • docs/analysis: Requirement Analysis report
  • docs/ERD.md: Entity Relationship Diagram and detailed descriptions
• prisma/schema: Prisma ORM schema files
• src/: Backend source directory
  • src/api/: Client SDK that would be published to the @ORGANIZATION/PROJECT-api
    • src/api/functional/: API functions generated by the nestia
    • src/api/structures/: DTO structures
  • src/controllers/: Controller classes of the Main Program
  • src/providers/: Implementations of the API functions
• test/: Test Automation Program
  • test/features: List of test functions
• nestia.config.ts: Configuration file of nestia
• package.json: NPM configuration
• tsconfig.json: TypeScript configuration for the main program

List of the run commands defined in the package.json are like below:

• Test
  • test: Run test automation program
  • benchmark: Run performance benchmark program
• Build
  • build: Build everything
  • build:main: Build main program (src directory)
  • build:test Build test automation program (test directory)
  • build:sdk: Build SDK into main program only
  • build:swagger: Build Swagger Documents
  • dev: Incremental build for development (test program)
• Deploy
  • package:api: Build and deploy the SDK library to the NPM
  • start: Start the backend server
  • start:dev: Start the backend server with incremental build and reload
• Webpack
  • webpack: Run webpack bundler
  • webpack:start: Start the backend server built by webpack
  • webpack:test: Run test program to the webpack built

Transform this template project to be yours.

When you've created a new backend project through this template project, you can specialize it to be suitable for you by changing some words. Replace below words through IDE specific function like Edit > Replace in Files (Ctrl + Shift + H), who've been supported by the VSCode.

This table shows the comprehensive metrics for each phase of the AutoBE generation pipeline. For each phase (Analyze, Database, Interface, Test, Realize), it tracks:

• Phase: The pipeline phase with success (✅) or failure (❌) indicator
• Generated: Count of artifacts produced (e.g., actors, documents, namespaces, models, operations, schemas, functions)
• FCSR: Function calling success rate
• Token Consumption: Total number of LLM tokens consumed during the phase
• Elapsed Time: Wall-clock time taken to complete the phase, including all AI agent operations and compiler feedback loops

These aggregate metrics provide visibility into the computational cost and time requirements of the entire generation process, helping identify resource-intensive phases and overall pipeline efficiency.

This table shows the reliability and quality metrics for AI agent function calling operations across all phases. Each row represents a specific operation type (e.g., analyzeScenario, prismaSchema, realizeWrite), tracking:

• Type: The AI agent operation name
• Trial: Total number of function calling attempts made by the agent
• Validation Failure: Calls that produced valid JSON but failed type validation
• JSON Parse Error: Calls that produced malformed JSON that couldn't be parsed
• Success: Calls that completed successfully with valid, validated responses
• Success Rate: Percentage of successful calls out of total attempts

These metrics reveal the effectiveness of AutoBE's validation feedback strategy powered by typia.llm.application<Class, Model>(). When function calls fail type validation, detailed error messages are fed back to the AI agent, enabling iterative correction through self-healing spiral loops.

Success rates vary based on model size and capability - smaller models may have lower initial success rates. However, validation feedback enables even weaker models to achieve high success rates through automatic correction cycles, demonstrating the power of compiler-driven development.

AutoBE is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0). If you modify AutoBE itself or offer it as a network service, you must make your source code available under the same license.

However, backend applications generated by AutoBE can be relicensed under any license you choose, such as MIT. This means you can freely use AutoBE-generated code in commercial projects without open source obligations, similar to how other code generation tools work.