Using AI For Real Projects and Decisions

I had an idea, and a hacky prototype I wanted to build. This post describes the key ways I leveraged AI to build it from scratch in a day while understanding every line of code, and considering options for design and architectural.

By leveraging a this tool for the whole process, I was able to maintain context and build faster.

The Starting Context

The context used is critical, here was my starting point:

• A vibe-coded prototype i’d been using for about a month. A very buggy monstrosity, but something that made me more productive and had been tweaked over time. Needed to be scrapped, but had a lot of intent and features in there that were useful.

• A product requirements document. This was created by asking AI to create a requirements document based on the vibe-coded prototype, and then I modified it. I changed parts that were details I wanted to do differently, I added sections for things I needed, and made it reflect what I wanted to build.

High-Level Strategy

First, I needed a plan. I gave the agent my prototype and product requirements and tasked it with creating a todos.md file.

It create a robust looking plan, but I didn’t see how I could verify things are correct, test it as I go, and check that I am doing this properly as I go. Phase 1 was to create all the database tables I would need, Phase 2 was to create all the UI, Phase 3 was to actually make the app work. I gave it guidance for how I like to build, using lean startup principles.

I gave it instructions that step 1 should be a hello world app, and every step should add a feature that can be used by a user. For example, adding the ability to create a project which would involve adding a create project form that adds data to a new database table.

With this, it created a really nice incremental plan. This allowed me to use AI to implement each one at a time, and refactor and test that it was to my liking and understand every line of code.

Technical Decisions

As I build things change. Things I didn’t think of come up, or things I thought would work didn’t. One of these was around the text editor to use for the app. I knew I'd need custom AI features and custom image widgets well integrated, and didn’t want something where I would need to do a clunky bolt-on.

I asked the agent for pro cons of lots of options, and it provided that for TipTap, Lexical, and Quill, recommending TipTap for its modularity and AI-readiness. I had some back and forth discussion asking about different features, like markdown compatibility, extensibility, etc., verifying everything by reading the docs as I went.

It did the same for the background processing pipeline, outlining the architectural tradeoffs between three options:

• asyncio: Native and integrated, but requires careful task management.

• Celery/Redis: Highly scalable, but adds architectural complexity.

• Subprocess: Simple to implement, but less robust for a web app.

All of this meant I could evaluate options faster, organize my thoughts, and most importantly I got to learn about options I may not have explored otherwise.

Implementation

In a post like this, everything feels sequential. In reality, the coding is mixed in with updating the plans, and making decisions about approaches.

For the coding part, I pointed the agent to the todos.md it helped generate and gave it the next task: "Implement Step 3: Create New Project CRUD Feature ". The prompt feels overly short, because all the context is in the document that describes step 4.

The agent then Completed that Step. It:

1. Added the Project model to database.py.

2. Generated the corresponding Alembic migration file to update the schema.

3. Implemented the full set of CRUD routes and views in main.py.

4. Created a button that used the CRUD features

That gave me a nice well scoped change that I new how to review, test, and refactor to make it great. Over the course of the implementation saved me a TON of time without sacrificing quality.

The Context Loop: A Better Workflow

This workflow doesn't replace the developer. It accelerates the developer, and cannot work without the developer.

Mastering lots of different full-stack workflows that work for different types of projects is how developers can leverage AI to be more efficient. It's the core of what we teach in our Elite AI-Assisted Coding course, a 3-week program for engineers who want to build reliable, customized AI workflows.