Atlas - AI Build Teammate for Hackathons

Atlas turns a raw hackathon idea into a scoped plan, roadmap, and submission-ready docs — built with Codex and GPT-5.6, so teams spend less time deciding and more time shipping

Comment

Inspiration

During OpenAI Build Week prep, we kept running into the same problem hackathon teams face every year: most of the clock gets spent deciding what to build, not building it. Ideas get pitched, reshaped, and re-pitched before a single line of code gets written — and by the time scope is settled, there's barely enough time left to build something demo-ready, let alone document it properly.

We watched this happen in real time with our own planning. The first idea was a simple AI project manager that answers questions. Then it became a multi-agent "startup team" with a PM, designer, engineer, and marketer all working in parallel. After actually reading the hackathon's official rules closely, the idea evolved again into a full "autonomous AI build team" — an orchestrator coordinating four or five specialized agents through a formal pipeline. Each version sounded more impressive than the last, but each one also added more moving parts, more failure points, and more time we didn't have.

That pattern is exactly the problem worth solving. So instead of building the most elaborate version of the idea, we built the tool that would have kept us from spiraling through five versions of the same idea in the first place. Atlas is that tool.

What it does

Atlas is an AI build teammate that takes a raw hackathon idea and turns it into a scoped plan, a time-boxed roadmap, and submission-ready documents — all in one linear flow, so a team can go from "what should we even build" to "here's our README and demo script" without losing days to indecision.

The flow is simple by design:

  1. Describe the idea in plain language.
  2. Atlas returns a demo-first scope — what's in, what's a distraction to defer, and a suggested build order and tech stack.
  3. Enter available days and hours per day, and Atlas generates a realistic, risk-aware roadmap with a protected time buffer.
  4. Generate a README draft (including a section explaining exactly how Codex and GPT-5.6 were used) and a three-part demo script timed to a 3-minute video.
  5. Track a live submission checklist built from Build Week's actual requirements, so nothing gets missed at the last minute.

To show Atlas isn't just a hackathon-specific novelty, it can also analyze existing project ideas from outside this hackathon — including a past healthcare screening assistant and a Slack-based care coordination tool — producing distinct, domain-appropriate scopes and roadmaps for each, along with an accurate breakdown of the real tools each project used.

How we built it

Atlas was built entirely inside Codex CLI across multiple sessions, using GPT-5.6 as the underlying model. Codex scaffolded the Express backend, wired all of the API endpoints (idea analysis, roadmap generation, document generation, and the submission checklist), built the single-page frontend, and handled iterative debugging and stabilization passes as the project grew. GPT-5.6 powers the actual reasoning behind each pipeline step, returning structured JSON so the frontend can render results reliably without parsing free-form text.

The product decisions were ours: settling on a single, linear pipeline instead of a multi-agent system, choosing the demo-first scoping philosophy, deciding what the roadmap and README generation should actually optimize for, and adding the project-selector feature to demonstrate versatility across different domains.

Challenges we ran into

Early on, we lost real build time to environment setup — PowerShell's script execution policy blocking npm installs, and inconsistent clipboard paste behavior in the Codex terminal, both resolved by switching to file-based prompt delivery instead of copy-paste.

The bigger challenge was API billing. We redeemed the hackathon's Codex credit, but it took time to realize this credit funds Codex CLI usage itself, not our app's own live calls to the OpenAI API — those are billed separately through the OpenAI Platform. Rather than lose a day waiting on a support reply, we added a MOCK_MODE toggle so development and testing could continue at zero cost, with a visible "Demo Mode" badge in the UI so this is disclosed honestly rather than hidden. This turned into a good habit rather than a workaround — every new feature could be built and verified without touching API usage at all.

Accomplishments that we're proud of

Shipping a complete, working, end-to-end pipeline rather than the most elaborate version of the idea. We're specifically proud of resisting the pull toward a multi-agent architecture that would have looked more impressive on paper but been far riskier to actually finish and demo reliably in the time we had.

We're also proud of the submission checklist feature being genuinely self-referential — Atlas tracks its own compliance with the very Build Week requirements it was built under, which we think is a small but honest demonstration of the tool actually working as intended.

What's next for Atlas

Enabling live GPT-5.6 analysis as the default mode once billing is fully sorted, and extending Atlas beyond planning into deeper build support — reading a project's actual repository, suggesting next tasks based on real code state, and helping debug issues as they come up. That would move Atlas from a planning teammate into a fuller build teammate, spanning the whole hackathon lifecycle rather than just its first mile.

Built With

Share this project:

Updates