The Day I Stopped Writing Boilerplate Code Manually

I didn’t quit writing boilerplate code because of some grand realization.

I stopped because I noticed something uncomfortable:

I was spending real focus on work that required none.

The Pattern I Couldn’t Ignore

Every boilerplate task looked the same:

• Copy an old file
• Rename things
• Miss one rename
• Fix it later

It felt like engineering.

It wasn’t.

It was transcription with bugs.

The Switch

Instead of copying files, I started describing what I wanted:

“Create a FastAPI endpoint with validation, error handling, and a service layer call. Follow this existing pattern.”

I got a full draft in seconds.

Not perfect. But structured.

And more importantly — complete.

Before vs After

Before (manual boilerplate):

@app.post("/users")
def create_user(user: UserCreate):
    if not user.email:
        raise ValueError("Email required")
    
    db_user = User(**user.dict())
    db.add(db_user)
    db.commit()
    return db_user

After (AI-generated + reviewed):

@app.post("/users", response_model=UserResponse)
def create_user(user: UserCreate):
    if not user.email:
        raise HTTPException(status_code=400, detail="Email required")

    db_user = User(**user.dict())
    db.add(db_user)
    db.commit()
    db.refresh(db_user)

    return db_user

The difference isn’t intelligence.

It’s completeness.

Why This Works

Boilerplate has:

• Known patterns
• Low decision-making
• High repetition

That’s exactly where automation wins.

“If you’ve written it more than twice, you probably shouldn’t be writing it again.”

The Unexpected Benefit

I review AI code better than I review my own.

Because I don’t trust it.

And that makes me careful.

Where It Still Fails

AI doesn’t know your codebase.

It will:

• Use the wrong patterns
• Ignore existing conventions
• Over-engineer simple things

So you still decide.

It just types faster.

What I Actually Stopped Doing

I didn’t stop coding.

I stopped writing predictable code.

Like this:

class Config(BaseModel):
    retries: int = 3
    timeout: float = 5.0

    @validator("timeout")
    def validate_timeout(cls, v):
        if v <= 0:
            raise ValueError("Timeout must be positive")
        return v

I can generate this in seconds.

But designing when and why it exists?

That’s still mine.

The Line That Matters

There are two types of work:

• Judgment → stays human
• Transcription → gets automated

Boilerplate is transcription.

Always was.

Final Thought

The shift is simple:

“If I can clearly describe it, I shouldn’t be manually writing it.”

That one rule removed hours of low-value work from my week.

Not by making me faster.

By making me stop doing things that never needed me in the first place.