Fastapi

FastAPI — FastAPI Mastery

Activate When

• User invokes /godmode:fastapi
• User says "build a FastAPI app", "async API"
• User asks about Pydantic, DI, async endpoints
• When working with Python async backend services
• User says "fastapi route", "FastAPI endpoint", "route for orders"

Workflow

Step 1: Project Assessment

# Detect FastAPI project
grep -l "fastapi" pyproject.toml requirements.txt \
  setup.py 2>/dev/null

# Check Python version
python3 --version

# Detect package manager
ls uv.lock poetry.lock Pipfile.lock 2>/dev/null

FASTAPI ASSESSMENT:
FastAPI version: 
Python: 
ORM: SQLAlchemy 2.0 async | Tortoise | SQLModel
Auth: JWT | OAuth2 | API keys
Package manager: uv (preferred) | Poetry | pip

IF Python = 80% overall
  Endpoint coverage: 100% of routes
  Schema tests: every validation rule tested
  IF test uses real external service: mock it

Step 7: Validation & Delivery

FASTAPI VALIDATION:
| Check                        | Status |
|------------------------------|--------|
| Async endpoints throughout   | ?      |
| Pydantic schemas for all I/O | ?      |
| DI via Depends() (no globals)| ?      |
| Async DB driver (asyncpg)    | ?      |
| N+1 prevention (selectin)    | ?      |
| Auth on protected endpoints  | ?      |
| Field() constraints on schemas| ?     |
| Alembic migrations present   | ?      |

Commit: "fastapi: — async endpoints, Pydantic schemas, pytest"

Key Behaviors

Never ask to continue. Loop autonomously until done.

1. Async everywhere. One sync layer blocks all.
2. Pydantic is your contract.
3. DI over imports. Makes testing trivial.
4. Separate schemas from models. They diverge.
5. Test with HTTPX, not requests.
6. Auto-generated docs are a feature. Keep accurate.
7. Background tasks for side effects.

HARD RULES

1. Always use async endpoints with async DB drivers.
2. Never return SQLAlchemy models from endpoints.
3. Never import DB sessions as module globals.
4. Always separate schemas: Create, Update, Response.
5. Always set expireoncommit=False on async sessions.
6. Always use selectin loading for async relationships.
7. Never use metadata.create_all() in production.
8. Always use Field() constraints on Pydantic schemas.
9. Never block event loop with CPU-intensive work.
10. Always use pydantic-settings for configuration.

Auto-Detection

1. FastAPI imports, Python version, package manager
2. ORM: SQLAlchemy/Tortoise/SQLModel, async driver
3. Auth: python-jose/authlib, Pydantic v1 vs v2
4. Tests: pytest/httpx, Alembic migrations

Output Format

Print: FastAPI: {action}, {endpoints} endpoints, {models} models. Tests: {status}. Verdict: {verdict}.

TSV Logging

timestamp	project	endpoints	models	migrations	tests	status

Keep/Discard Discipline

KEEP if: tests pass AND quality improved
  AND no regressions
DISCARD if: tests fail OR performance regressed

Stop Conditions

STOP when ANY of:
  - All tasks complete and validated
  - User requests stop
  - Max iterations reached

Error Recovery

• mypy fails: fix models → schemas → services → routers.
• Tests fail: verify test DB configured.
• Alembic: multiple heads → alembic merge heads.
• Async issues: replace requests with httpx.AsyncClient.
• DI errors: verify Depends() function signatures.

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: arbazkhan971
• Source: arbazkhan971/godmode
• License: MIT

Install and usage instructions live in the source repository linked above.