add-backend-entity

Generate FastAPI backend entity modules with models, schemas, and routers.

5|Updated Feb 12, 2026
One-click install
npx skills add https://github.com/agusmdev/fullstack-ai-template --skill add-backend-entity
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: add-backend-entity
Source: https://github.com/agusmdev/fullstack-ai-template/tree/main/template/.pi/skills/add-backend-entity
Command: npx skills add https://github.com/agusmdev/fullstack-ai-template --skill add-backend-entity

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill provides a complete, scaffolded approach for adding a new backend entity to a FastAPI project, eliminating ad-hoc boilerplate and ensuring consistency across modules.

Core Features & Use Cases

  • Model, Schemas, Repository, Service, Router: provides a standardized structure to implement a new API resource.
  • Filters, Dependencies, and Registration: ensures consistent querying, wiring, and endpoint exposure.
  • Migration Readiness: includes guidance for creating and applying Alembic migrations. Use Case: When adding a new domain entity (e.g., Product) to a FastAPI app you can follow this guide to generate all necessary layers in a uniform way.

Quick Start

Follow this guide to scaffold a new backend module by creating the model, schemas, repository, service, filters, dependencies, and router, then register it in the app.

Frequently Asked Questions about add-backend-entity

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I add a new backend entity to a FastAPI project?▼

To add a new backend entity to a FastAPI project, generate the full module structure including SQLAlchemy models, Pydantic schemas, repository, service, and router. This enforces a 3-layer architecture with consistent naming and dependency wiring.

What is the best way to structure a new FastAPI API resource with SQLAlchemy?▼

The best way to structure a new FastAPI API resource is following a 3-layer architecture that separates models, schemas, repository, service, and router components. This ensures consistent querying patterns, dependency wiring, and endpoint exposure.

Does this FastAPI scaffolding approach include Alembic migration readiness?▼

Yes, this FastAPI scaffolding approach includes migration readiness by providing guidance for creating and applying Alembic migrations. It ensures typed SQLAlchemy models are ready for database schema updates.

Can I use this to generate Pydantic schemas and repository patterns for FastAPI?▼

Yes, you can use this to generate Pydantic schemas and repository patterns for FastAPI. It automates creating typed schemas, service layers, filters, and dependencies to ensure uniform module wiring.

What do I need to scaffold a FastAPI module with PostgreSQL integration?▼

To scaffold a FastAPI module with PostgreSQL integration, you need a project following a 3-layer architecture. The process generates typed SQLAlchemy models, dependencies, router configuration, and registration within your existing application.

Why generate separate repository and service layers when adding a FastAPI module?▼

Generating separate repository and service layers when adding a FastAPI module enforces consistent querying and business logic separation. This 3-layer architecture standardizes endpoint exposure, filtering, and dependency wiring across new API resources.