Relying on willpower is exhausting.

The temptations to cut corners are constant. Every PR, every commit, every generation — you have to consciously choose discipline.

Willpower depletes. Systems don’t.

This post is about building systems that make responsible AI use the path of least resistance.

The Principle

You can’t automate judgment.

No tool will tell you if your architecture is right. No linter will verify you understand the code. No CI pipeline will check if you’re solving the actual problem.

But you can automate the scaffolding.

You can create gates that force you to apply judgment. Friction points that make skipping verification require conscious effort. Systems that catch the obvious stuff so your judgment focuses on what matters.

The Forcing Functions

Pre-Commit Hooks

The first gate. Code can’t even leave your machine without passing basic checks.

What to enforce:

• Tests must pass. No committing broken code.
• Linting must pass. Catch obvious issues.
• Type checking must pass. If you’re using TypeScript.
• Test coverage threshold. New code needs tests.

The key: make these fast. Slow pre-commit hooks get bypassed. Keep it under 30 seconds.

# Example: Husky + lint-staged setup
npx husky add .husky/pre-commit "npx lint-staged"

CI/CD Gates

The second gate. Code can’t merge without passing thorough checks.

What to enforce:

• Full test suite. Not just the fast ones.
• Coverage requirements. Enforce minimums.
• Build must succeed. Obvious but important.
• Security scans. Catch vulnerabilities.
• Type coverage. If applicable.

Make the pipeline strict. If it’s easy to bypass, it will be bypassed.

PR Templates

The third gate. Force yourself to document verification.

A template that requires:

## What does this change?
[Describe the change]

## How did I verify this?
- [ ] I can explain this code
- [ ] I ran this locally
- [ ] I wrote tests for new behavior
- [ ] I checked edge cases
- [ ] I verified against requirements

## What could go wrong?
[Think through failure modes]

The checklist forces reflection. Even if you’re tempted to skip, you have to consciously uncheck boxes.

Staged Rollouts

The fourth gate. Limit blast radius when something goes wrong.

• Feature flags. Ship dark, enable gradually.
• Percentage rollouts. 1%, 10%, 50%, 100%.
• Monitoring. Know immediately when something breaks.
• Easy rollback. One button to revert.

This isn’t AI-specific. But it matters more when AI helped write the code.

The Verification Checklist

Before you ship anything, run through this:

Understanding

• Can I explain this code to a colleague?
• Do I know why it works, not just that it works?
• Could I debug this at 2am if it breaks?

Verification

• Did I verify AI’s explanation against reality?
• Did I run this code, not just read it?
• Did I test edge cases, not just happy path?

Quality

• Would I be comfortable defending this architecture?
• Do the tests catch real bugs, or just hit coverage?
• Is this the simplest solution that works?

Responsibility

• Am I being transparent about AI’s involvement?
• Do I own this code fully?
• Would I ship this if my name was on it alone?

If any answer is “no” — pause, reflect, fix.

The Self-Check Ritual

Build a ritual before every PR:

1. Re-read the diff. Not skim. Read.
2. Explain it out loud. To yourself, to a duck, to anyone.
3. Run through the checklist. Honestly.
4. Ask: would I bet money this works?

Takes 5 minutes. Catches most problems.

Making It Stick

Start small

Don’t implement everything at once. Add one gate, make it stick, add another.

Make it team-wide

Individual discipline fails. Team norms persist. Get everyone on the same standards.

Track metrics

• How many bugs reach production?
• How long does verification take?
• How often are gates bypassed?

What gets measured gets managed.

Celebrate catches

When the gates catch a bug, celebrate it. “The pre-commit hook saved us from shipping X.” Positive reinforcement for the system.

The Meta-Point

All of this exists because we’re human. We get tired. We cut corners. We rationalize.

The systems don’t eliminate that. They just make the responsible path easier than the irresponsible path.

Make it harder to skip verification than to do it.

That’s the whole strategy.

The Complete Picture

This series covered:

1. The story — how I migrated a payment system with AI
2. The framework — six phases, five practices
3. The human element — why discipline is hard
4. The automation — systems that force responsibility

The framework tells you what to do. The human element tells you what to watch for. The automation makes it easier to follow through.

Together, they make responsible AI development sustainable.

---

The complete series:

• How I Migrated a Payment System with AI
• The Responsible AI Development Framework
• Why AI Makes Us Lazy (And How to Fight It)
• Automating Responsible AI Development (this post)

---

I’m speaking about this topic at DevFest Cebu 2025. If you want to discuss responsible AI development, find me there.