AI Writes Python Code, However Sustaining It Is Nonetheless Your Job

Picture by Writer

# Introduction

 
AI coding instruments are getting impressively good at writing Python code that works. They’ll construct complete functions and implement advanced algorithms in minutes. Nonetheless, the code AI generates is usually a ache to keep up.

If you’re utilizing instruments like Claude Code, GitHub Copilot, or Cursor’s agentic mode, you’ve in all probability skilled this. The AI helps you ship working code quick, however the fee reveals up later. You’ve possible refactored a bloated operate simply to grasp the way it works weeks after it was generated.

The issue is not that AI writes dangerous code — although it typically does — it’s that AI optimizes for “working now” and finishing the necessities in your immediate, when you want code that’s readable and maintainable in the long run. This text reveals you the way to bridge this hole with a deal with Python-specific methods.

# Avoiding the Clean Canvas Lure

 
The most important mistake builders make is asking AI to begin from scratch. AI brokers work finest with constraints and pointers.

Earlier than you write your first immediate, arrange the fundamentals of the undertaking your self. This implies selecting your undertaking construction — putting in your core libraries and implementing just a few working examples — to set the tone. This might sound counterproductive, but it surely helps with getting AI to put in writing code that aligns higher with what you want in your utility.

Begin by constructing a few options manually. If you’re constructing an API, implement one full endpoint your self with all of the patterns you need: dependency injection, correct error dealing with, database entry, and validation. This turns into the reference implementation.

Say you write this primary endpoint manually:

from fastapi import APIRouter, Relies upon, HTTPException
from sqlalchemy.orm import Session

router = APIRouter()

# Assume get_db and Consumer mannequin are outlined elsewhere
async def get_user(user_id: int, db: Session = Relies upon(get_db)):
    person = db.question(Consumer).filter(Consumer.id == user_id).first()
    if not person:
        increase HTTPException(status_code=404, element="Consumer not discovered")
    return person

When AI sees this sample, it understands how we deal with dependencies, how we question databases, and the way we deal with lacking information.

The identical applies to your undertaking construction. Create your directories, arrange your imports, and configure your testing framework. AI shouldn’t be making these architectural selections.

# Making Python’s Sort System Do the Heavy Lifting

 
Python’s dynamic typing is versatile, however that flexibility turns into a legal responsibility when AI is writing your code. Make kind hints important guardrails as an alternative of a nice-to-have in your utility code.

Strict typing catches AI errors earlier than they attain manufacturing. Once you require kind hints on each operate signature and run mypy in strict mode, the AI can not take shortcuts. It can not return ambiguous varieties or settle for parameters that could be strings or could be lists.

Extra importantly, strict varieties drive higher design. For instance, an AI agent making an attempt to put in writing a operate that accepts knowledge: dict could make many assumptions about what’s in that dictionary. Nonetheless, an AI agent writing a operate that accepts knowledge: UserCreateRequest the place UserCreateRequest is a Pydantic mannequin has precisely one interpretation.

# This constrains AI to put in writing appropriate code
from pydantic import BaseModel, EmailStr

class UserCreateRequest(BaseModel):
    identify: str
    e-mail: EmailStr
    age: int

class UserResponse(BaseModel):
    id: int
    identify: str
    e-mail: EmailStr

def process_user(knowledge: UserCreateRequest) -> UserResponse:
    go

# Reasonably than this
def process_user(knowledge: dict) -> dict:
    go

Use libraries that implement contracts: SQLAlchemy 2.0 with type-checked fashions and FastAPI with response fashions are glorious decisions. These will not be simply good practices; they’re constraints that maintain AI on monitor.

Set mypy to strict mode and make passing kind checks non-negotiable. When AI generates code that fails kind checking, it can iterate till it passes. This automated suggestions loop produces higher code than any quantity of immediate engineering.

# Creating Documentation to Information AI

 
Most tasks have documentation that builders ignore. For AI brokers, you want documentation they really use — like a README.md file with pointers. This implies a single file with clear, particular guidelines.

Create a CLAUDE.md or AGENTS.md file at your undertaking root. Don’t make it too lengthy. Deal with what is exclusive about your undertaking somewhat than common Python finest practices.

Your AI pointers ought to specify:

• Challenge construction and the place several types of code belong
• Which libraries to make use of for widespread duties
• Particular patterns to observe (level to instance recordsdata)
• Express forbidden patterns
• Testing necessities

Right here is an instance AGENTS.md file:

# Challenge Tips

## Construction
/src/api - FastAPI routers
/src/companies - enterprise logic
/src/fashions - SQLAlchemy fashions
/src/schemas - Pydantic fashions

## Patterns
- All companies inherit from BaseService (see src/companies/base.py)
- All database entry goes by repository sample (see src/repositories/)
- Use dependency injection for all exterior dependencies

## Requirements
- Sort hints on all capabilities
- Docstrings utilizing Google type
- Features beneath 50 traces
- Run `mypy --strict` and `ruff examine` earlier than committing

## By no means
- No naked besides clauses
- No kind: ignore feedback
- No mutable default arguments
- No world state

The hot button is being particular. Don’t merely say “observe finest practices.” Level to the precise file that demonstrates the sample. Don’t solely say “deal with errors correctly;” present the error dealing with sample you need.

# Writing Prompts That Level to Examples

 
Generic prompts produce generic code. Particular prompts that reference your present codebase produce extra maintainable code.

As a substitute of asking AI to “add authentication,” stroll it by the implementation with references to your patterns. Right here is an instance of such a immediate that factors to examples:

Implement JWT authentication in src/companies/auth_service.py. Observe the identical construction as UserService in src/companies/user_service.py. Use bcrypt for password hashing (already in necessities.txt).
Add authentication dependency in src/api/dependencies.py following the sample of get_db.
Create Pydantic schemas in src/schemas/auth.py just like person.py.
Add pytest checks in checks/test_auth_service.py utilizing fixtures from conftest.py.

Discover how each instruction factors to an present file or sample. You aren’t asking AI to construct out an structure; you might be asking it to use what you have to a brand new function.

When the AI generates code, evaluation it in opposition to your patterns. Does it use the identical dependency injection strategy? Does it observe the identical error dealing with? Does it set up imports the identical means? If not, level out the discrepancy and ask it to align with the prevailing sample.

# Planning Earlier than Implementing

 
AI brokers can transfer quick, which may often make them much less helpful if pace comes on the expense of construction. Use plan mode or ask for an implementation plan earlier than any code will get written.

A planning step forces the AI to assume by dependencies and construction. It additionally provides you an opportunity to catch architectural issues — similar to round dependencies or redundant companies — earlier than they’re carried out.

Ask for a plan that specifies:

• Which recordsdata can be created or modified
• What dependencies exist between elements
• Which present patterns can be adopted
• What checks are wanted

Overview this plan such as you would evaluation a design doc. Test that the AI understands your undertaking construction. Confirm it’s utilizing the fitting libraries and make sure it’s not reinventing one thing that already exists.

If the plan appears good, let the AI execute it. If not, appropriate the plan earlier than any code will get written. It’s simpler to repair a foul plan than to repair dangerous code.

# Asking AI to Write Assessments That Truly Take a look at

 
AI is nice and tremendous quick at writing checks. Nonetheless, AI will not be environment friendly at writing helpful checks except you might be particular about what “helpful” means.

Default AI take a look at habits is to check the glad path and nothing else. You get checks that confirm the code works when the whole lot goes proper, which is strictly when you do not want checks.

Specify your testing necessities explicitly. For each function, require:

• Completely satisfied path take a look at
• Validation error checks to examine what occurs with invalid enter
• Edge case checks for empty values, None, boundary situations, and extra
• Error dealing with checks for database failures, exterior service failures, and the like

Level AI to your present take a look at recordsdata as examples. When you have good take a look at patterns already, AI will write helpful checks, too. When you wouldn’t have good checks but, write just a few your self first.

# Validating Output Systematically

 
After AI generates code, don’t simply examine if it runs. Run it by a guidelines.

Your validation guidelines ought to embody questions like the next:

• Does it go mypy strict mode
• Does it observe patterns from present code
• Are all capabilities beneath 50 traces
• Do checks cowl edge instances and errors
• Are there kind hints on all capabilities
• Does it use the required libraries appropriately

Automate what you possibly can. Arrange pre-commit hooks that run mypy, Ruff, and pytest. If AI-generated code fails these checks, it doesn’t get dedicated.

For what you can not automate, you’ll spot widespread anti-patterns after reviewing sufficient AI code — similar to capabilities that do an excessive amount of, error dealing with that swallows exceptions, or validation logic combined with enterprise logic.

# Implementing a Sensible Workflow

 
Allow us to now put collectively the whole lot now we have mentioned so far.

You begin a brand new undertaking. You spend time establishing the construction, selecting and putting in libraries, and writing a few instance options. You create CLAUDE.md along with your pointers and write particular Pydantic fashions.

Now you ask AI to implement a brand new function. You write an in depth immediate pointing to your examples. AI generates a plan. You evaluation and approve it. AI writes the code. You run kind checking and checks. All the things passes. You evaluation the code in opposition to your patterns. It matches. You commit.

Complete time from immediate to commit might solely be round quarter-hour for a function that may have taken you an hour to put in writing manually. However extra importantly, the code you get is less complicated to keep up — it follows the patterns you established.

The following function goes quicker as a result of AI has extra examples to study from. The code turns into extra constant over time as a result of each new function reinforces the prevailing patterns.

# Wrapping Up

 
With AI coding instruments proving tremendous helpful, your job as a developer or a knowledge skilled is altering. You at the moment are spending much less time writing code and extra time on:

• Designing methods and selecting architectures
• Creating reference implementations of patterns
• Writing constraints and pointers
• Reviewing AI output and sustaining the standard bar

The talent that issues most will not be writing code quicker. Reasonably, it’s designing methods that constrain AI to put in writing maintainable code. It’s realizing which practices scale and which create technical debt. I hope you discovered this text useful even when you don’t use Python as your programming language of selection. Tell us what else you assume we will do to maintain AI-generated Python code maintainable. Maintain exploring!
 
 

Bala Priya C is a developer and technical author from India. She likes working on the intersection of math, programming, knowledge science, and content material creation. Her areas of curiosity and experience embody DevOps, knowledge science, and pure language processing. She enjoys studying, writing, coding, and low! Presently, she’s engaged on studying and sharing her information with the developer neighborhood by authoring tutorials, how-to guides, opinion items, and extra. Bala additionally creates participating useful resource overviews and coding tutorials.