10-backend-python

10-backend-python is a cursor rule for coding agents from bybren-llc/a-safe-pulse. It costs 0 tokens per session (610 once invoked), scanned A, a copy of 10-backend-python, MIT.

Backend Python development rules for FastAPI, SQLAlchemy 2.x, async patterns, and Alembic migrations.

Cursor rule

Install

Getting it into your agent

One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.

agentmods
npx agentmods add rules/bybren-llc/a-safe-pulse/10-backend-python
Clone the repo
git clone --depth 1 https://github.com/bybren-llc/a-safe-pulse

Wrote this? Show the measurements

A badge with what this costs and how it scanned, read live from this page, so it follows the numbers instead of freezing them. Markdown for a README, HTML for a documentation site or a project page.

agentmods badge for 10-backend-python

README.md
[![agentmods](https://agentmods.dev/badge/rules/bybren-llc/a-safe-pulse/10-backend-python.svg)](https://agentmods.dev/rules/bybren-llc/a-safe-pulse/10-backend-python)
Your own site
<a href="https://agentmods.dev/rules/bybren-llc/a-safe-pulse/10-backend-python"><img src="https://agentmods.dev/badge/rules/bybren-llc/a-safe-pulse/10-backend-python.svg" alt="Measured on agentmods" height="20"></a>
Per session 0 Nothing until a file matches its globs; then the whole rule loads.
When invoked 610 The whole file, excluding the scripts and references it only reads on demand.
Security scan A 0 findings. Scan, not verified.
Origin 100% copy Near-identical to another mod in the catalogue.
Token cost

What it costs to keep this loaded

Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.

ModelPer sessionOnce invoked
Fable 5 $0.00000 $0.00610
Opus 5 $0.00000 $0.00305
Sonnet 5 $0.00000 $0.00122
Haiku 4.5 $0.00000 $0.00061

Measured today against content hash 9a0ecf654a3e, method: parsed. Prices are Anthropic first-party input rates as of 2026-08-30, from the pricing page.

Security

Grade A, and why

10-backend-python scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured today.

A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.

Nothing flagged

None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.

Origin

This is a copy

100% identical to 10-backend-python — 2 lines differ, which has more behind it and is treated as the original. This page carries a canonical link to it rather than competing with it.

docs/archive/harness-upstream/cursor-rules/10-backend-python.mdc · 84 lines

How it starts

The opening of the file, as written. The whole thing — 84 lines — stays where its author put it; the contents beside it link to each section on GitHub.

Backend Python Rules

These rules apply when working on backend Python code in core/ and edgekit/.

Technology Stack

  • Framework: FastAPI (Python 3.11+)
  • ORM: SQLAlchemy 2.x with async session patterns
  • Migrations: Alembic
  • Database: PostgreSQL 16
  • Authentication: JWT (custom implementation)

Coding Standards

  • Use ruff for linting and formatting (config in pyproject.toml)
  • Always run ruff check . before committing
  • Use mypy for type checking
  • Python 3.11+ features are allowed (StrEnum, etc.)
  • Use async/await patterns for all FastAPI endpoints

Database Operations

CRITICAL: All database operations MUST use RLS context helpers.

# User operations
async with with_user_context(session, user_id) as ctx:
    result = await ctx.execute(select(Model).where(Model.user_id == user_id))

# Admin operations
async with with_admin_context(session, user_id) as ctx:
    result = await ctx.execute(select(Model))

# System/background operations
async with with_system_context(session, "source_name") as ctx:
    result = await ctx.execute(insert(Model).values(data))

Never use direct session calls without RLS context wrappers.

Migration Workflow

alembic revision --autogenerate -m "description"  # Create migration
alembic upgrade head                               # Apply locally
# Review the generated migration file before committing
git add alembic/versions/
git commit -m "feat(db): add migration description [ASP-XXX]"

Rules:

  • Always create proper Alembic migrations (never skip)
  • Review auto-generated migrations for correctness
  • Add RLS policies for any new tables
  • Schema changes require System Architect approval

FastAPI Patterns

  • Use dependency injection for database sessions
  • Use Pydantic v2 models for request/response validation
  • Use proper HTTP status codes
  • Include OpenAPI documentation (FastAPI generates this)
  • Use structured logging

Testing

  • Use pytest with async support (pytest-asyncio)
  • Run pytest tests/ before committing
  • Integration tests go in tests/integration/
  • E2E tests go in tests/e2e/

Read the full file on GitHub · 84 lines

Changes

What this file has done since we first saw it

Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.

  1. today First seen · 84 lines · 0 tokens per session scan A 9a0ecf654a3e

Subscribe to this mod's changes

10-backend-python is a cursor rule published in the GitHub repository bybren-llc/a-safe-pulse (9 stars, last pushed 5mo ago), licensed MIT. It costs nothing until one of its globs matches a file; then it loads 610 tokens. A static security scan graded it A with 0 findings. It is 100% identical to 10-backend-python, differing in 2 lines, and is treated as a copy.