Skip to content
Kashif Bhatti
Menu

AI-Assisted Software Development

I'm a backend developer and an AI enthusiast. For more than a year I've used AI coding agents every day to work faster across different stacks, and I design the architecture and review every change myself.

How I work with AI

AI agents are fast and tireless, but they don't know your business and they don't carry responsibility for the result. This workflow keeps the speed and puts the judgement where it belongs.

  1. 1

    Understand the requirement

    I start with the problem, not the tool: who the users are, what they need to do, and what "done" looks like. AI can only build the right thing if I have defined it clearly first.

  2. 2

    Design the architecture and data model

    I decide the components, how they talk to each other, the database schema and the boundaries between them. This is the part that is expensive to change later, so I never delegate it.

  3. 3

    Break the work into small tasks

    Each task is small enough to review properly in one sitting: one endpoint, one screen, one migration. Small steps keep mistakes small and easy to spot.

  4. 4

    Direct the AI agent with precise prompts

    I give the agent the context it needs (the relevant files, conventions, constraints and acceptance criteria) so it produces code that fits the existing design instead of inventing its own.

  5. 5

    Review and test every change

    I read every line the agent writes, run it, and test it. Anything I cannot explain does not get merged. This is where most of my time goes, and it is the reason the approach works.

  6. 6

    Refactor and document

    Once a feature works, I clean up duplication, tighten names and structure, and write down the decisions so the next developer, or the next AI session, starts from solid ground.

Principles I don't hand to AI

These are engineering decisions, and they stay with me on every project.

System architecture and design
I choose the structure of the system and the boundaries between parts; the agent works inside them.
SOLID and clean code
Small classes with one job, clear names and dependencies that point the right way, whoever typed the code.
Separation of concerns
Business rules stay out of controllers and widgets, data access stays in one layer, and UI stays UI.
Security checks
Input validation, authorization, secrets handling and dependency choices are reviewed by me, not trusted to a model.
Testing
Generated code gets the same tests as hand-written code; agents can draft tests, but I decide what must be covered.
Version control and code review
Small commits with clear messages, one change per branch, and a review before anything reaches the main branch.

Across different stacks

PHP and Laravel are my first and natural stack, with 5+ years of professional experience. The backend principles I learned there carry to Node.js and other frameworks, and with AI help I've also shipped front-end and mobile projects. That means I can choose the right tool for a project instead of forcing everything into one.

Picking a stack is a business decision as well as a technical one. A shop that has to keep selling when the internet drops needs an offline-first desktop app; a product with a mobile audience may need Flutter; a fast marketing site may suit Next.js. The engineering principles above stay the same whichever stack the project ends up in.

Core backend stack

  • PHP
  • Laravel
  • MySQL
  • REST APIs

Other backends

  • Node.js
  • Express
  • Supabase

Front end and mobile, with AI help

  • Flutter
  • Next.js
  • TypeScript
  • Vue
  • Inertia

Projects built this way

Each project page shows the architecture, what I designed myself, what the AI agents generated, and the problems I had to solve along the way.

Other side projects

What this means for you

Faster delivery

Agents handle the repetitive parts of a build, such as scaffolding, boilerplate and first drafts of tests, so more of your budget goes into the features that make your product different.

The same quality bar

Every change is reviewed, tested and committed by me, exactly as if I had typed it. You get readable code that another developer can maintain, not a pile of generated files.

Clear ownership

You work with one developer who understands the whole system and answers for it. If something breaks, I know why, because I designed it and I reviewed it.

Need a Laravel back end, an API or a cross-platform app? See my services or read about my experience.

Want to build something with this approach?

Tell me what you need and which stack you have in mind. I'll tell you honestly whether I'm the right fit.

Message on WhatsAppSend a project brief