From AI Skeptic to Building Delivery Around AI
Two years ago, AI seemed like a toy pretending to be human — confident, polite, and usually wrong.
Today, it's how my team ships software at MetaFoundry Labs.
The journey wasn't a flip. It was a sequence of small revisions to how I worked — until one specific Tuesday when AI built an integration in two hours that should have taken me over a day. That was when I realized the development lifecycle itself had changed.
From Toy to Tool
I started using AI where most people do: cleaning up emails, replacing Google for coding lookups. None of it was revolutionary.
The shift started when I let AI into the codebase. In-IDE assistants gave it access to everything I was working on. For narrow tasks (write this function, refactor this method) it was excellent. For anything bigger, it got messy fast. Large refactors went sideways. The code drifted from our conventions. I lost confidence in what was mine and what was generated.
The lesson I learned the hard way: commit after every acceptable change. That single workflow change is what made the rest possible.
From Tool to Junior Developer
Once I started reviewing AI's work like I'd review a junior developer's, the relationship changed. I questioned its approach. I pushed back on its suggestions and was sometimes proven wrong. I had it write unit tests. I had it diagnose broken builds and propose fixes.
It wasn't a peer yet, but it was somebody on the team.
The Moment It Changed
I was researching how to integrate Power BI paginated reports into the front end, with a backend auto-printing flow through a cloud printing service. That kind of integration has quirks at every layer — auth, embed tokens, render config, print job orchestration. I had read enough to know the shape of the work. AI offered to implement the whole thing.
I said yes, mostly out of skepticism. Let's see what you can do. Worst case, I'll use it as boilerplate and finish the task manually.
A couple of hours later (after a handful of build errors got fixed and the auth flow got tweaked) the integration worked. Reports rendered in the front end. Cloud printing handled the dispatch. The quirks I'd been bracing for never became my problem.
Surprise turned into appreciation. A task I had scoped for a full 1-2 days of frustrating trial-and-error was finished in two hours. It wasn't just the hours saved. It was the frustration that comes with them. AI had taken the whole task (research, design, implementation, working through every quirk) and delivered something that worked end to end. It had stopped being a junior. It had become a teammate.
What AI-DLC Looks Like For Us Now
That moment is what AI-DLC (the AI-Driven Development Life Cycle) actually means in practice. AI isn't a coding aid. It's a collaborator embedded at every step of how we deliver, with every role using it differently.
This is how we now work on our industrial WMS, Themis-Trace, and on every client engagement:
Discovery (Claude, Notion, & Figma). Our Product Team captures stakeholder feedback using Notion. They then use Claude to generate a full Product Requirements Document (PRD) and a functioning prototype with either Claude Design or Figma Make.
Backlog grooming (Notion & Claude). User stories and acceptance criteria get generated from the PRD with Claude and land on the sprint board in Notion ready to estimate.
Technical requirements (Claude & Notion). Engineers use Claude as a research tool — pulling in patterns, library docs, and integration considerations as they shape the technical approach and update the technical spec that accompanies the feature description in Notion.
Test design (Claude). Testers use Claude as a brainstorming partner to surface use cases and edge cases that might otherwise be missed. They use Claude to break down the PRD and technical specs into fully executable test plans.
Code generation (Claude & Cursor). Engineers hand the PRD and technical requirements to Claude Code. It generates the feature boilerplate and base unit tests against our tech stack. Engineers finish the fine-grained logic with an IDE AI assistant (typically Claude or Cursor).
Test automation (Claude & Cursor/VS Code). Testers hand the PRD, tech specs, and test plan to Claude Code. It generates the boilerplate API and UI tests. Testers finish the fine-grained assertions in Cursor or VS Code.
The result: new features in Themis-Trace get built in days, not weeks. Clients interact with working software sooner, and the roadmap evolves from usage instead of speculation.
Where Humans Still Lead
AI can write the code. It can't tell you whether the code should exist. When a client asks for a feature that would compromise multi-tenant isolation, no agent catches that — an engineer does. Architecture, domain boundaries, security, client trust — that judgment is still ours.
Where We're Going Next
Here's what we're building toward at MetaFoundry: AI moves from collaborator to team. The PRD becomes the source of truth, and a chain of agents takes it from there. One agent drafts the user stories. Another expands them into use cases. A critique agent loops with both, sending work back until it meets the bar.
Code generation and unit tests stay where they are today — except the coding agent now opens the pull request. That PR has to clear a developer code review and pass validation from three more agents wearing different hats: software engineer, security, performance. The developer can hand the PR back to the coding agent, or push their own commit, until all three agents sign off.
Final Thoughts
The lesson for us has been simple: the breakthrough is not using AI more. It is redesigning the delivery process around what AI can now reliably own — while keeping humans accountable for judgment.
If you try one workflow change, make it this: commit after every acceptable AI change, and review the model’s work like you would a junior dev.
