What I’ve Been Building With AI (ChatGPT + Claude)

Hi everyone — I'm Glen.

I live and work in New Zealand and spend most of my time building software. My day job is as a FileMaker developer, but lately I’ve been spending a lot of my spare time experimenting with AI-assisted development and seeing how far a single developer can push things with the current generation of tools.

I've been in IT for quite a while (though relatively new to the FileMaker ecosystem), and the speed at which AI tools can help you move from idea to working system is pretty remarkable.

Over the last few weeks I decided to test something properly.

Instead of just experimenting with prompts or small scripts, I started building a real system to see what AI-first development actually looks like in practice.

The project is called InvoiceReady.

What I'm building

The goal of InvoiceReady is fairly straightforward: help companies validate invoices before sending them into networks like Peppol, where invoices often get rejected because of formatting issues, missing fields, or buyer-specific rules.

If you've worked with systems like Peppol you’ll know that the hardest part isn’t generating the invoice — it’s making sure the invoice satisfies all the rules before it gets sent.

So the platform focuses on catching those issues early.

Right now the system includes:

• a canonical invoice data model
• a multi-layer validation engine
• buyer rule management
• destination profile configuration
• invoice versioning and history
• a sandbox testing environment
• an external API designed for integration with systems like FileMaker

The validation engine works in layers.

1. System checks
2. Peppol baseline rules
3. Buyer-specific requirements
4. Destination rules

Each layer validates the invoice data before it ever gets sent to a network.

The idea is simple: catch problems before an invoice ever leaves your system.

The development setup

The interesting part isn’t just the project itself, but how it’s being built.

Instead of a traditional workflow, I’ve been using a combination of:

• ChatGPT for architectural thinking, planning, and writing
• Claude Code for repository implementation
• Next.js + TypeScript for the application
• Supabase for the database

For anyone curious about the tooling: I'm not using the free tiers.

I'm currently on the paid plans just above the free tier for both ChatGPT and Claude.

That gives enough usage to work with them continuously while building real software, without constantly hitting limits. Even combined, the monthly cost is still fairly modest compared to traditional development tooling.

How the workflow actually works

The most important thing I've learned so far is that AI development only works well if you control the workflow.

The loop I'm using looks something like this:

1. Think through the architecture
2. Define a clear implementation plan
3. Ask Claude to implement the change in the repository
4. Run type checks and tests
5. Iterate

In other words, the AI isn't just asked to "build something".

It is asked to implement a plan.

The rule I've been following is simple:

Never let the AI start coding without a plan.

Once the plan is clear, the implementation phase becomes dramatically faster.

Tasks like scaffolding routes, wiring APIs, generating types, creating migrations, and even producing tests can happen in minutes.

The bottleneck stops being implementation.

The bottleneck becomes decision quality.

What surprised me

The biggest surprise wasn’t that AI can generate code.

It was how quickly the implementation layer stops being the constraint.

Once the architecture is clear, the AI can produce large amounts of surrounding implementation very quickly.

What ends up taking the most time is deciding:

• what the system should actually do
• where the logic should live
• what the smallest safe change is
• what shouldn't be built at all

Those are architectural questions.

AI can help with them, but they still require human judgment.

What still requires human oversight

AI is very good at producing code that looks plausible.

But plausible code isn’t the same as a coherent system.

The areas that still require the most careful attention are things like:

• system architecture
• domain modelling
• product decisions
• defining boundaries between components
• deciding when something is the wrong feature entirely

In other words, the AI can accelerate implementation, but it doesn’t replace the thinking that keeps a system stable.

If anything, those decisions become more important because implementation is now so fast.

Why I'm writing about this

There’s a lot of hype around AI coding tools right now.

Some of it is deserved.

But the real shift isn't simply that AI can write code.

The real shift is that a single developer can now coordinate something that behaves more like a small engineering team — if the workflow is structured properly.

That’s what I’m experimenting with.

Building a real system.

Using AI as the primary implementation layer.

And documenting what works, what breaks, and what turns into chaos if you're not careful.

I'll keep sharing what I learn as the project evolves.