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

TL;DR Highlight

A Python web framework forked from Django, redesigned with type hints, a single convention, and an agent-friendly structure, making it easier for LLMs to read and modify code.

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

snippet

# 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

vibe-codingA development approach that quickly creates apps by entrusting code to AI without a clear design. It is highly productive, but it is difficult to review code quality.

monorepositoryA method of managing multiple packages or subprojects in a single Git repository. Plain manages dozens of packages in a single repo.

Class-based ViewA method of structuring HTTP request processing logic as classes in Django. It is highly reusable, but the inheritance hierarchy is complex and difficult to follow.

opinionated frameworkA framework that enforces a specific way of doing things. While reducing choices, it ensures that the entire team uses the same pattern, increasing code consistency. Rails is a representative example.

CLAUDE.mdA context file created to allow the Claude AI agent to refer to when first opening a project. It contains project structure, rules, and precautions, allowing the agent to generate more accurate code.

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