--- title: "How We Build BudgetWorks OS: AI Generates, Humans Decide" description: "See how BudgetWorks OS uses AI to generate code, tasks, and modules — then humans review, refine, and ship." url: https://www.budgetapp.works/en/blog/working-with-ai-best-practice-workflow canonical_url: https://www.budgetapp.works/en/blog/working-with-ai-best-practice-workflow last_updated: 2026-10-12 --- [ Back to Blog](/en/blog) March 11, 2026 532 views # How We Build BudgetWorks OS: AI Generates, Humans Decide ![How We Build BudgetWorks OS: AI Generates, Humans Decide](/cdn-cgi/image/width=1536,quality=80,format=auto/https://public-api.budgetapp.works/api/public/media/c0f2d234-93fe-4433-b04b-5bd61fb1b764) ## 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 ```mermaid 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: ```mermaid 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: | Task | Priority | Why AI Got It Right | | ----------------------------- | -------- | ----------------------------------------- | | Design lf\_\* database schema | High | Foundational — everything depends on this | | Case Management CRUD | High | Core feature, well-understood pattern | | Client Intake forms | High | Matches existing e-forms module | | Time Tracking and timesheets | High | Billable hours are the business model | | Trust Accounting (IOLTA) | High | Legal compliance requirement | | Billing and invoicing | High | Reuses existing sales patterns | | Court Deadlines and Calendar | Medium | Important but can ship without | | Conflict Check | Medium | Can be added incrementally | | Document Assembly | Medium | Templates follow existing patterns | 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: ```mermaid 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: ```mermaid 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: ```mermaid 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: | Metric | Count | | ---------------------------- | ----- | | Total modules | 26 | | Database tables | 515 | | API routes | 2600+ | | Vue pages | 84+ | | Override route files | 36 | | Postgres RPC functions | 14 | | Development phases completed | 15 | Each phase follows the same loop: **Project created, AI generates tasks, human reviews, AI generates code, human reviews, ship.** ## The Full Picture ```mermaid 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._ #ai #claude #workflow #mermaid #best-practices ### Want to see it in action? Learn how BudgetWorks OS can transform your business operations. [Try Live Demo](/en/try) --- Site map for agents: [llms.txt](https://www.budgetapp.works/llms.txt) · [sitemap.md](https://www.budgetapp.works/sitemap.md)