How We Build BudgetWorks OS: AI Generates, Humans Decide

BudgetWorks OS ships 26 AI modules — Finance, HR, CRM, Projects, POS, Helpdesk, Booking, VoIP, and more — built by a small team moving at startup speed. Our secret? A tight loop between AI generation and human review, all tracked inside BudgetWorks OS itself.

This post walks through our actual workflow.

The BudgetWorks Development Loop

flowchart TD
    A[Create Project in BudgetWorks] --> B[AI Generates Tasks on Kanban]
    B --> C[Human Reviews Task Breakdown]
    C -->|Adjust| B
    C -->|Approve| D[AI Generates Code]
    D --> E[Human Reviews Code]
    E -->|Needs Changes| F[Refine with AI]
    F --> D
    E -->|Approved| G[Test and Validate]
    G -->|Fails| F
    G -->|Passes| H[Commit and Deploy]
    H --> I[Screenshot for Demo Page]

Every module in BudgetWorks OS — from the Lawfirm module we are building now to the Teleman VoIP system — follows this exact loop.

Step 1: Create the Project

Everything starts with a project in BudgetWorks OS itself. We eat our own dogfood.

When we decided to build the Lawfirm Module, we created project #101 in our Kanban board. The project description captures the scope:

Case management, client intake, matter tracking, billing (hourly/flat/contingency), trust accounting (IOLTA), document assembly, court deadlines, conflict checks, and time tracking.

This description becomes the AI's primary context.

Step 2: AI Generates the Task Breakdown

Instead of manually writing every task, we describe the module to AI and it generates a structured Kanban board:

flowchart LR
    subgraph AI Generated
        A[Schema Design] --> B[Backend Routes]
        B --> C[Admin Vue Pages]
        C --> D[Dashboard]
    end
    subgraph Human Added
        E[Edge Cases]
        F[Integration Tests]
        G[Security Review]
    end

For the Lawfirm module, AI generated 13 tasks:

The human review step is critical — AI suggested the right tasks, but we adjusted priorities and added integration concerns it missed.

Step 3: AI Generates Code

With tasks defined, AI generates code following our established patterns. The key is context — our CLAUDE.md file tells AI exactly how we build:

## DB Patterns
All DB access via supabase-py (no raw SQL)
Override routes for business logic
Generated routes for CRUD

## Gotchas
users.id is BIGINT not UUID
Use Optional[X] not X | None
FastAPI route ordering: /reorder BEFORE /{id}

With this context, AI generates code that fits our codebase from the first try:

sequenceDiagram
    participant Dev as Developer
    participant AI as Claude Code
    participant KB as Kanban Board
    participant Code as Codebase
    Dev->>KB: Pick task from To Do
    KB->>Dev: Task: Design lf_* schema
    Dev->>AI: Context + task description
    AI->>Code: Generate schema SQL
    AI->>Code: Generate Pydantic models
    AI->>Code: Generate FastAPI routes
    Dev->>Dev: Review generated code
    Dev->>KB: Move task to Review
    Dev->>Code: Commit and push
    Dev->>KB: Move task to Done

Step 4: Human Reviews and Refines

AI output is never shipped without review. Here is our decision tree:

flowchart TD
    A[AI Generated Code] --> B{Follows our patterns?}
    B -->|No| C[Point AI to existing module as example]
    B -->|Yes| D{Correct business logic?}
    D -->|No| E[Describe the domain rule AI missed]
    D -->|Yes| F{Security ok?}
    F -->|No| G[Flag vulnerability]
    F -->|Yes| H{Over-engineered?}
    H -->|Yes| I[Ask AI to simplify]
    H -->|No| J[Ship it]
    C --> A
    E --> A
    G --> A
    I --> A

What we actually catch in review:

• Pattern drift — AI sometimes invents new patterns instead of following existing ones. We say: "Follow the pattern in sales.py."
• Missing constraints — AI may not know that contacts.id is UUID while users.id is BIGINT. Our CLAUDE.md catches this.
• Over-engineering — AI loves abstractions. We push back: "Three similar lines are better than a premature abstraction."
• Security — Always check for unvalidated input, especially on public endpoints.

Step 5: The Kanban Flow

Every task moves through our board:

flowchart LR
    A[To Do] --> B[In Progress]
    B --> C[Review]
    C -->|Changes Needed| B
    C -->|Approved| D[Done]

To Do — AI-generated task breakdown, human-reviewed

In Progress — Developer and AI pair-programming

Review — Human checks AI output against patterns, security, and business logic

Done — Committed, tested, deployed

The board itself lives in BudgetWorks OS. We manage the product that manages our work.

Real Numbers

Here is what this workflow has produced:

Each phase follows the same loop: Project created, AI generates tasks, human reviews, AI generates code, human reviews, ship.

The Full Picture

mindmap
  root((BudgetWorks OS))
    AI Generates
      Task breakdown
      Database schema
      Backend routes
      Frontend pages
      Blog content
    Human Decides
      Architecture choices
      Priority ordering
      Security review
      Business logic
      Ship or iterate
    Tracked In
      Kanban boards
      Project timesheets
      Git commits
      Demo screenshots

Try It Yourself

The same workflow engine that builds BudgetWorks OS is available inside BudgetWorks OS:

1. Create a project with Kanban boards, task stages, and milestones
2. Track time with built-in timers and timesheets
3. Manage files in the Drive module with version control
4. Automate approvals with the Workflow BPM engine
5. Report progress with project dashboards and budget tracking

All 26 modules run on the same database, same API, same UI — deployed on your own infrastructure.

This post was generated using the exact AI workflow described above — task created in BudgetWorks OS project #2, content generated by AI, reviewed and refined by a human. The Mermaid diagrams? AI-generated too.