Last Tuesday, I had an idea for a simple task management app. Nothing fancy — just a personal tool to track my side projects with deadlines, priority levels, and progress notes. The kind of thing that would normally take me a full weekend to build properly.

I finished it in three hours. Here’s exactly how.

The Setup (15 minutes)

I started by describing the whole project to my AI coding tool before writing a single line of code. This is the step most people skip, and it’s the most important one.

Here’s roughly what I said:

I want to build a task management app. Tech stack: FastAPI backend, SQLite database, vanilla HTML/CSS/JS frontend. Features: create tasks with title, description, priority (low/medium/high), and due date. List all tasks sorted by due date. Mark tasks as complete. Delete tasks. Simple, clean UI — nothing fancy.

From this description, the AI generated a project structure, and I used that as my blueprint.

taskflow/
├── main.py          # FastAPI app with all endpoints
├── models.py        # SQLAlchemy models
├── database.py      # Database connection setup
├── static/
│   ├── index.html
│   ├── style.css
│   └── app.js
└── requirements.txt

Clean and simple. No over-engineering.

The Backend (45 minutes)

I built the backend through conversation, one piece at a time.

First, the database model:

from sqlalchemy import Column, Integer, String, Boolean, Date, DateTime
from sqlalchemy.sql import func
from database import Base

class Task(Base):
    __tablename__ = "tasks"

    id = Column(Integer, primary_key=True, index=True)
    title = Column(String, nullable=False)
    description = Column(String, default="")
    priority = Column(String, default="medium")
    due_date = Column(Date, nullable=True)
    completed = Column(Boolean, default=False)
    created_at = Column(DateTime, server_default=func.now())

Then the API endpoints:

I asked for all CRUD operations, specifying that I wanted them to return JSON and use Pydantic models for validation. The AI generated five endpoints:

  • GET /tasks — list all tasks, sorted by due date
  • POST /tasks — create a new task
  • GET /tasks/{id} — get a single task
  • PATCH /tasks/{id} — update a task (including marking complete)
  • DELETE /tasks/{id} — delete a task

Each endpoint took about one prompt-and-review cycle. I caught two small issues — a missing validation check and an incorrect sort order — and fixed them with follow-up prompts.

The key was being specific about behavior: “Sort by due date ascending, with null dates at the end. Completed tasks should appear last regardless of due date.”

The Frontend (60 minutes)

The frontend took the longest, but mostly because I was picky about how it looked and felt.

I started with the HTML structure:

<div class="container">
  <header>
    <h1>Taskflow</h1>
    <button id="add-btn">New Task</button>
  </header>

  <div id="task-list"></div>

  <dialog id="task-dialog">
    <form id="task-form">
      <input type="text" name="title" placeholder="Task title" required>
      <textarea name="description" placeholder="Description"></textarea>
      <select name="priority">
        <option value="low">Low</option>
        <option value="medium" selected>Medium</option>
        <option value="high">High</option>
      </select>
      <input type="date" name="due_date">
      <div class="dialog-actions">
        <button type="button" id="cancel-btn">Cancel</button>
        <button type="submit">Save</button>
      </div>
    </form>
  </dialog>
</div>

I used the <dialog> element for the task creation modal — no JavaScript libraries needed. The AI suggested this, and it was a great call.

For the CSS, I gave it specific constraints: “Use a neutral color palette. Cards for each task with a subtle left border color based on priority — green for low, amber for medium, red for high. Completed tasks should be visually muted.”

The JavaScript was straightforward fetch calls to the API. I asked the AI to write it without any framework, using modern vanilla JS. The whole thing was about 80 lines.

Connecting Everything (30 minutes)

The last stretch was wiring it all together. I asked the AI to add static file serving to FastAPI, set up CORS (even though everything was same-origin, it’s good practice), and create the SQLite database on first run.

I also added a couple of quality-of-life features through quick prompts:

  • “Add a confirmation dialog before deleting a task”
  • “Show a relative date for the due date — like ‘Tomorrow’ or ‘In 3 days’ or ‘Overdue’”

Both took one prompt each. The relative date logic was something I would have had to look up or think through manually. The AI nailed it on the first try.

Testing and Polish (30 minutes)

I spent the last half hour manually testing everything, fixing a couple of edge cases, and tweaking the CSS until it felt right.

The bugs I found were minor:

  • The task list didn’t refresh after deleting a task (one line fix)
  • The date input didn’t have a min value, so you could create tasks due in the past (added min={today})

Both were caught by actually using the app, not by the AI. This is an important point — you still need to test your work. AI gets you to 90% fast, but that last 10% is your responsibility.

What I Learned

Three hours for a working full-stack app with a clean UI. Not a prototype — something I actually use every day now.

Here are the takeaways:

Describe first, build second. Spending 15 minutes describing the whole project upfront saved me from going in circles. The AI had context for every subsequent prompt.

Be specific about behavior, not just features. “Sort tasks” is vague. “Sort by due date ascending with null dates last and completed tasks at the bottom” gets you exactly what you want.

Build in layers. Database → API → Frontend → Polish. Each layer was verified before moving to the next. This made debugging trivial because I always knew which layer to look at.

Don’t expect perfection. I caught and fixed maybe five small issues along the way. That’s normal. The speed comes from getting 90% of the code right instantly, not from getting 100% right.

If you haven’t tried building a complete project with AI assistance, give it a shot this weekend. Pick something small, something you’d actually use. You might surprise yourself.