u/milonspace

Every time I start a new dashboard project, I end up fighting with massive UI libraries or ripping out hundreds of lines of unused code from "premium" templates. I wanted a clean, unopinionated starting point.

So, I built and open-sourced **PeopleBase Directory**.

It's a lightweight Single Page Application built with React, Vite, and Tailwind CSS. It provides a solid foundation—a responsive navigation rail, standard data tables, and Recharts integrations—without dictating your backend architecture.

But the biggest difference is how it handles styling. I built an **"LLM-safe" design system**.

If you use AI coding agents (like Cursor, Copilot, or standard LLMs), you know they love to invent random hex codes and arbitrary padding values. To fix this, PeopleBase uses a strict `DESIGN.md` file as the source of truth, mapped directly to native Tailwind CSS custom properties.

By banning arbitrary values and forcing the use of semantic tokens (e.g., `var(--color-brand-primary)`), both human developers and AI agents are constrained to the defined design system.

The repository also includes:

* A `.wiki/` directory following the Open Knowledge Format (OKF) for Architecture Decision Records (ADRs).

It's designed to be a clean slate that you can actually understand and scale.

I'd love for you to check it out, fork it, and let me know your thoughts on the LLM-safe design approach.

Link: https://github.com/bymilon/peoplebase-directory

Over the past few months, I noticed the same pattern.

The prompt gets longer.
The chat gets longer.
Context gets bigger.
Eventually, the conversation becomes the project.

I wanted something more structured.

So I started building FactoryOS, an open-source workspace for Spec-Driven Development and AI coding workflows.

The idea is simple:

Product intent becomes structured specs.
Specs become implementation plans.
Plans become executable task groups.
AI coding teams work on one bounded task at a time.
Verification proves the implementation.
Humans approve before anything important ships.

Instead of treating chat history as the source of truth, the repository becomes the source of truth:

.specs/    Product truth
.tasks/    Execution truth
AGENTS.md  Repository rules
skills/    Reusable workflows
code/      Implementation
tests/     Proof

I'm also experimenting with a small set of runtime roles instead of lots of specialized agents:

Main Integrator
Explorer
Worker
QA

The goal isn't maximum autonomy. It's reducing context growth, keeping token usage predictable, and making work easier to resume, review, and verify.

I'm interested in feedback from people using Codex CLI, Claude Code, Cursor, or similar tools.

A few questions:

What breaks first in your AI-assisted workflow as projects get larger?
How are you keeping context and token costs under control?
Do you think structured specs and task trackers are worth the overhead, or do you prefer chat-driven workflows?

Repository:
https://github.com/bymilon/factoryos

I'd appreciate honest criticism, especially from people who've hit the limits of long AI coding sessions.

GitHub - bymilon/peoplebase-directory: Open-source React people operations dashboard starter built with TypeScript, Vite, Tailwind CSS, and Recharts.

I built an open-source "software factory" on top of Codex CLI. Looking for feedback from people building with AI every day.