AbridgeAI

AbridgeAI turns a rough idea by typing a project idea in plain English into a build-ready plan in one run

Inspiration

Every side project starts the same way: a half-formed idea, a blank README, and a weekend you'll never get back. I kept watching good ideas die at the "now what?" step — before a single file was created. AbridgeAI came from wanting a tool that does the thinking a project needs before the coding starts: give it one sentence, and it hands you a feasibility verdict, an architecture, a stack, a real starter scaffold, and a week-by-week plan — instead of a blank screen.

What it does

AbridgeAI runs a seven-stage deterministic planning pipeline on your local backend:

Builder Signals — reads your public GitHub profile for signal (optional)
Research & Opportunities — market scan, risks, recommended direction
Feasibility Assessment — a /100 score across five weighted axes
Architecture Direction — module breakdown and data-flow spine
Tech Stack — comfort-matched recommendation, or your own custom combo
Builder Plan & Scaffold — a downloadable starter repo (.zip) with a project-specific README.md and PLAN.md
Project Brief — the full brief, viewable or exported as Markdown

Feasibility is scored as

$$\text{score} = \min\left(100,\ c + s + p + t + b\right)$$

over five axes — idea clarity, stack fit, scope, time realism, and builder fit. Above 70 it says GO; between 50 and 70 it says Proceed with caution; below that, Rethink / reshape — so the plan is honest before you commit.

If you add a custom stack like FastAPI + React + PostgreSQL + Docker, the text gets parsed into structured components, the scaffold is auto-chosen for the backend language, and the README renders each layer. Type C++ + Rust together and both are recognized — the pipeline lists both and picks the best matching starter base.

How we built it

The backend is Express + Node, the frontend is React + Vite, and all planning logic lives server-side behind a typed stage registry (stages.js) — the UI never rebuilds project logic, it just consumes structured results over HTTP. Four stages are LLM-powered: Gemini goes first; if it's missing, out of quota, or unparseable, Groq is tried automatically; if both fail, a deterministic engine takes over so the app never 500s. Badges in the UI tell you which path ran (Gemini · live, Groq · live, LLM · cached, or fallback).

Even the deterministic fallback is idea-aware. Items are picked by hash-scored seeding — every candidate scores as

$$s_i = H(\text{seed} + \text{poolItem}_i)$$

with the best-seeded options chosen, so two similar ideas still diverge and a run never re-bills the same prompt twice (results are cached per input hash).

Challenges we ran into

The biggest was billing discipline: the Gemini free tier allows ~20 requests/day on this model, and one run already uses four — so a deployment "worked yesterday" and shows fallback today for no code reason. Debugging that led to the whole resilience story: a real provider chain (Gemini → Groq → deterministic) instead of a single point of failure. We also had to keep LLM output honest — models return malformed JSON, miss keys, or invent content — so every stage sanitizes and clamps LLM results before anything touches the UI.

Accomplishments that we're proud of

The pipeline always produces a complete plan — demo-proof, even with no keys
A real downloadable scaffold, not just text: README.md, PLAN.md, a test, a fixture, and a core module that embeds the project's planned architecture
Deterministic fallbacks are idea-specific, not generic canned text

What we learned

Resilient over ambitious: a fallback chain beats a single "perfect" model
LLM output is a contract to validate, not a source of truth
A typed stage registry made adding stages trivial — single source of truth
Caching identical inputs prevents cost and guarantees stable re-runs

What's next for AbridgeAI

More starter languages (C++/C#, web frameworks) and richer scaffolds
A persisted project store + cloud run for multi-user use
Cost-tiered provider routing (which stage uses which provider, by cost)

Built With

ai
developer-tools
express.js
gemini-ai
groq-cloud
hackathon
llm
node.js
project-planning
react
scaffolding
typescript
vite
web-app

Submitted to

AI Builders Hackathon

Created by

I contributed primarily to the frontend development and overall product experience of AbridgeAI, with a strong focus on building and refining the dashboard. I worked on structuring the dashboard interface, improving the layout and navigation, and refining the way different stages of the project-planning workflow are presented to the user. I focused on making the interface clean, intuitive, and consistent while ensuring that the existing functionality and data flow remained intact.

I also worked on refining the pipeline structure, making targeted improvements to how the different stages of the AbridgeAI workflow are organized and connected. This included helping improve the flow of information between stages while keeping the existing agent functionality and outputs consistent.

Another part of my contribution was ensuring consistent branding and asset integration across the application. I integrated the AbridgeAI logo properly across both the frontend and backend-served application, making sure the asset paths and presentation worked correctly in the different environments.

Overall, my contribution focused on turning the underlying AbridgeAI functionality into a polished, cohesive, and usable product experience, while refining the pipeline and ensuring the application's visual identity and functionality remained consistent throughout.

Ruchira Rajesh Jagshettiwar
I designed and built the end-to-end backend planning system, the LLM integration, and drove the project from a demo to a submission-ready product.

- Data-driven pipeline architecture: Refactored the planning engine into a typed, data-driven backend — introduced stages.js as the single source of truth for the 7-stage pipeline, a generic runner (runPipeline.js) with typed context, and a canonical brief model (brief/model.js + render.js) shared by the in-app cards and Markdown export. All logic lives server-side behind an Express API (/api/meta, /api/plan, /api/export), fully decoupling the React UI from the planning logic so the frontend is a thin render-only client.

- LLM-powered stages with resilient fallbacks: Integrated Google Gemini into the research, architecture, builder, and brief stages with strict JSON prompts engineered for idea-specific output. Added per-input-hash caching (cache-aside) so identical runs never re-bill, and layered a Groq fallback behind Gemini plus idea-aware deterministic fallbacks — so a complete, structured plan is always produced, never a 500, even with no API keys configured.

- Feature work: Built deadline-aware milestone sizing (Day-based plans for ≤14-day windows), custom stack parsing (e.g. FastAPI + React + PostgreSQL, C++ + Rust), GitHub-signal builder profiles, polished in-app provider badges (Gemini · live / Groq · live / LLM · cached / fallback), and starter-scaffold generation with downloadable project-specific READMEs and PLAN.md.

- Deployment, security & configuration: Built the Vercel serverless entrypoint (api/index.js) sharing a single Express app factory, and set up environment handling through .env/.env.example so secrets are gitignored and the app degrades gracefully when keys are missing. Also fixed the dark-mode contrast issue for accessible UI.

- Documentation & submission assets: Authored the full README with architecture and deployment guides, the project brief model, the submission checklist with a 15-minute demo runbook, and captured the screenshots — so reviewers can run, deploy, and demo the app in minutes.

Suzanne Daniel Thomas
Chasing the light