Show HN: Plain – The full-stack Python framework designed for humans and agents

Who Should Read

Python web developers attempting vibe-coding or AI agent-based development using LLMs (Claude, Codex, etc.). Especially developers frustrated with Django's complex legacy.

Core Mechanics

• Plain is a fork of Django refined over years of actual operation, maintaining Django's core structure while organizing unnecessary complexity and rough edges discovered in the field.
• The biggest feature is its Postgres-exclusive model design, explicitly declared using type annotations like `email: str = types.EmailField()`, allowing you to grasp the structure with a single read of the code.
• Based on the philosophy that 'code that is good for humans is also good for AI,' it adopts an explicit, typed, and predictable code style to reduce the probability of errors when LLMs infer code.
• Getting started is agent-friendly. You can entrust project setup to a Claude agent with the command `claude "$(curl -sSf https://plainframework.com/start.md)"` or run it directly with `uvx plain-start my-app`.
• Full-stack packages such as plain-admin, plain-auth, plain-jobs, plain-oauth, and plain-tailwind are provided together in a monorepo structure, allowing agents to attach functionality in a predetermined manner without choices.
• Detailed READMEs and examples are included within each module, designed to allow agents to obtain context from within the codebase without searching external documents.
• It adopts a simpler View structure instead of Django's Class-based View, eliminating the need for agents to trace inheritance hierarchies and delve into the source code.
• A CLAUDE.md file is included in the repo root to support Claude agents in immediately understanding the project context.

Evidence

• There was criticism that 'creating something new for agents is counterproductive.' The logic was that a new framework not in the LLM's training data would inevitably be worse than Django at using it, but the counterargument was that 'agents read markdown documents and accurately call even unfamiliar CLIs, the important thing is whether the interface is predictable.'
• The opinion that Django's flexibility is actually poison to agents gained traction. 'Django can do the same thing in six ways, but Plain forces only one, reducing the surface area for agents to infer,' was one analysis.
• There was harsh criticism that 'it stole the Django codebase, just changed the name, and added AI marketing,' but users who have been watching Plain for a long time defended it, saying 'it was developed long before vibe-coding became popular, and the design decisions are solid.'
• There was criticism of the Class-based View approach. If it's an agent-friendly framework, using CBV with an indirection layer is counterproductive, as agents have to repeatedly read the base classes.
• There was a comment that the model declaration method (type annotation + field assignment) is similar to strawberry GraphQL, and there was a response that this style is much better in terms of developer UX. 'Minimizing the amount of code to review with rule-based conventions is key to creating sustainable projects in the age of agents.'

How to Apply

• If you plan to start a new project with an AI agent like Claude or Codex, you can entrust the initial setup to the agent with the command `mkdir my-app && cd my-app && claude "$(curl -sSf https://plainframework.com/start.md)"`. The agent will automatically set up the project structure following the instructions in the plain-start script.
• If you want to quickly create a Django-based side project with AI-assisted coding, you can benefit from Plain's single convention structure, allowing the agent to generate code without worrying about 'how to do it' and reducing the amount of code humans need to review.
• If you are considering introducing agents to an existing Django project, you can first apply the same agent context document structure as Plain's modules and the CLAUDE.md pattern to your existing project.
• If your team is creating a new Python web app using Postgres as the DB, you can start with `uvx plain-start my-app` and quickly build a full-stack app by combining built-in packages like plain-admin, plain-auth, and plain-jobs. Having only one choice reduces team code review costs.

Code Example

# Start project with agent
mkdir my-app && cd my-app && claude "$(curl -sSf https://plainframework.com/start.md)"

# Or start directly with uv
uvx plain-start my-app

# Plain's model declaration method (type annotation + field)
# app/users/models.py
from plain import postgres
from plain.postgres import types
from plain.postgres.functions import Now
from plain.passwords.models import PasswordField

@postgres.register_model
class User(postgres.Model):
    email: str = types.EmailField()
    password: str = PasswordField()
    display_name: str = types.CharField(max_length=100)
    is_admin: bool = types.BooleanField(default=False)
    created_at: datetime = types.DateTimeField(default=Now)

Terminology

Related Resources

• https://github.com/dropseed/plain
• https://plainframework.com/start/
• https://plainframework.com/start.md
• https://plainframework.com/about/