AI Didn't Build It. I Did - With AI.

I've been experimenting with AI-assisted development for a while, but building WorkTrak's Payment Detail workflow gave me a better way to understand what this actually means in practice.

The interesting part wasn't asking AI to write a React component.

It was figuring out where AI should help, and where I should stay in control.

Think First. Build Second.

I started with the product problem rather than the implementation.

The original payment model was based around marking individual time entries as paid. As the product evolved, that model started creating problems around payment history, grouping, reversals, and understanding exactly what had been paid.

I used ChatGPT to explore the problem, challenge different approaches, define the payment lifecycle, and break the work into smaller implementation phases.

That process helped me arrive at a much clearer model:

Draft -> Paid -> Reopened -> Paid

with Reverted as a terminal state.

Only after the product behavior made sense did I move into implementation.

Then I Moved Into the Repository

For implementation, I used OpenCode directly inside the WorkTrak repository.

Instead of asking an AI to generate an entire feature, I worked incrementally:

Define a phase -> implement -> review -> identify gaps -> iterate.

The work eventually touched the React UI, TypeScript domain models, API layer, persistence, dialogs, audit history, and lifecycle behavior.

This approach also exposed something important: AI can produce technically valid code that is still incomplete from a product perspective.

For example, parts of the payment lifecycle could exist in the backend before the UI fully represented that behavior. I had to recognize the gap, rethink the implementation, and continue iterating.

AI Is Fast. That Doesn't Mean It Is Right.

This is probably the biggest lesson I've taken from the experiment.

I don't think of AI-generated code as the final answer.

I think of it as a very fast implementation partner.

My workflow became:

Problem

-> Explore with AI

-> Make the decision

-> Build with AI

-> Review

-> Test

-> Iterate

The human part doesn't disappear. In some ways, it becomes more important.

You still need to understand the product, recognize when something doesn't make sense, question the implementation, and verify that the result actually works.

What Changed for Me

Before working this way, I mostly thought about AI as a productivity tool.

Now I see it more as a new interface for building software.

ChatGPT helped me think through the problem.

OpenCode helped me move from decisions to implementation much faster.

But the product decisions, trade-offs, review, and responsibility for the final result were still mine.

That's the part of AI-assisted development I'm most interested in exploring next.