GitHub Copilot CLI for FastAPI: a practical guide

Start copilot in the project root and treat it as a coding agent that works best when the repository has a clear contract. For FastAPI that means route files, Pydantic schemas, dependency injection, and tests must be discoverable and consistent. This guide shows how to set up that contract and use GitHub Copilot CLI for daily FastAPI work.

FastAPI’s declarative style matches Copilot CLI’s strengths

FastAPI is declarative: you describe paths, request and response models, and dependencies, then let the framework enforce them. GitHub Copilot CLI reads the whole project context, including instruction files, so it can implement a change across a router, a schema, and the test suite in one turn. The agent shines when it follows existing patterns instead of inventing new ones, and FastAPI projects tend to have predictable separation between api, schemas, models, and tests. With explicit rules around Pydantic v2 and response_model, the diffs stay small and reviewable, which is exactly what you want from an agent.

Give Copilot CLI a FastAPI contract in one file

GitHub Copilot CLI looks for repo-wide instructions in .github/copilot-instructions.md or AGENTS.md. For a FastAPI project, put the layout, the commands you actually use, and rules that prevent common agent mistakes. Keep the file short and concrete. A realistic example:

# FastAPI project instructions

## Layout
- `app/main.py` - app entrypoint and router registration
- `app/models/` - SQLAlchemy models
- `app/schemas/` - Pydantic schemas (v2)
- `app/api/` - route modules
- `app/services/` - business logic
- `app/db.py` - database session and engine
- `tests/` - pytest tests using `TestClient`

## Commands
- Install: `pip install -e '.[dev]'`
- Run: `uvicorn app.main:app --reload`
- Test: `pytest -q`
- Lint: `ruff check . && ruff format --check .`

## Rules
- Use Pydantic v2 style: `model_config = ConfigDict(from_attributes=True)` for ORM output.
- Use `Annotated` for dependencies, e.g. `session: Session = Depends(get_session)`.
- All routes are `async def` unless using sync DB driver; then keep sync route and sync session.
- Always define `response_model` on routes that return data.
- Keep route handlers thin; put business logic in services.
- Don't add manual validation if FastAPI already returns 422; rely on Pydantic.
- Use `TestClient` from `fastapi.testclient` in tests; reset the database per test when needed.

The keys are the test and lint commands, because the agent will run them after each change, and the Pydantic v2 rule, because the most common FastAPI breakage comes from mixing v1 and v2 syntax.

A small loop: plan, change, test, review

Use a small cycle: plan the change, ask for one step at a time, run the tests, review the diff. Start with a clear spec in your prompt. For more on planning with agents, see Spec-driven development with AI agents: a practical guide.

Example prompts for typical FastAPI tasks:

• “Add a GET /items/{item_id} endpoint that returns an ItemRead schema from the database. Use the existing get_item service function and include a 404 response if not found.”
• “Create a Pydantic model ItemCreate with fields name: str, price: float, is_available: bool. Add a route POST /items that persists it and returns ItemRead.”
• “Update the dependency get_current_user to raise HTTPException(status_code=401) when the token is missing. Add a test for this case.”
• “Refactor the update_item route to use the service layer instead of DB session directly. Keep the existing response shape.”
• “Write pytest tests with TestClient for the new user registration endpoint, covering validation and duplicate email.”

After each prompt, run pytest -q and ruff check . yourself or ask the agent to run them. Review the diff with git diff before moving on. For a deeper walkthrough of the agent workflow, see How to use GitHub Copilot CLI: a step-by-step guide.

FastAPI tasks Copilot CLI handles well, and the pitfalls to watch

The agent excels at generating CRUD route modules from existing service and schema patterns, converting SQLAlchemy models to Pydantic schemas with from_attributes, adding dependencies with Annotated, updating test_client tests, and adding OpenAPI metadata. It can also refactor sync handlers to async when the stack allows it.

Watch closely around these FastAPI-specific pitfalls:

• Pydantic v1 vs v2: wrong Config vs model_config, or mixing orm_mode and from_attributes.
• Returning ORM objects without from_attributes=True, so FastAPI serializes only a subset or raises errors.
• Sync database sessions inside async def routes, blocking the event loop.
• Adding custom try/except blocks that return inconsistent error shapes, when FastAPI already produces a structured 422.
• Forgetting response_model, which can leak internal fields.
• Changing dependency scopes accidentally, especially with yield dependencies and test overrides.
• Creating circular imports between routers, schemas, and services.

Verify FastAPI changes with TestClient and pytest

Always test through TestClient after an agent change. The agent can write and run tests, but you should still verify the behavior. The following table pairs test focus areas with prompts that work well.

Run pytest -q and ruff check . after every turn. For integration, start uvicorn app.main:app and hit the endpoint manually or with a browser-based test. The agent can even drive browser tests; see AI agent browser testing: let the agent check your app if that fits your workflow.

Run parallel agents on one FastAPI repo with AgentVera

AgentVera is a desktop app that runs GitHub Copilot CLI and other coding agents side by side in real terminal panels. For FastAPI work, the most useful features are parallel agents in separate git worktrees, so one can add a route while another updates Pydantic schemas without overwriting files; automatic code review that links findings to file:line across routers, schemas, and tests; checkpoints that let you undo a bad dependency refactor and replay the turn step by step; and token budgets that keep each agent’s change small enough to review quickly. That matches FastAPI’s modular codebase and test-gated workflow.

Keep FastAPI changes small and test-gated

GitHub Copilot CLI becomes a reliable FastAPI assistant when you invest a little in a repo instruction file, keep changes small, and verify with pytest and ruff. Use the working loop above and let AgentVera parallelize agents safely when the project grows. The result is less boilerplate writing and more time on API design.