ScaleCraft

What inspired me

Beginner developers often learn how to make code work, but rarely know how to make it scale. General AI assistants only fix code when specifically prompted, leaving a gap for students who suffer from "unknown unknowns." They don't know they need caching or rate limiting, so they never ask an AI to build it. I wanted to build a proactive mentor—a tool that doesn't wait for a prompt, but actively scans a repository to find these hidden architectural flaws and teaches the developer how to fix them.

How I built it

ScaleCraft is a full-stack application built with React/Next.js and Tailwind CSS on the frontend, and Node.js/Express on the backend.

Because I joined the hackathon late and missed the free API credits deadline, I had to be incredibly strategic with my development workflow:

• I started in the OpenAI Codex desktop app using GPT-5.5 to generate the basic project structure and boilerplate.
• I then switched Codex to GPT-5.6 to architect the core backend logic—specifically the deterministic file parser.
• When I eventually hit my free tier usage limits in the desktop app, I seamlessly transitioned to the ChatGPT web interface to debug the final UI components.
• For the live runtime, the backend uses the free Google Gemini API to evaluate the code, keeping the application entirely free to run.

Challenges I faced

The biggest engineering challenge was handling large codebases without blowing past LLM context windows or incurring heavy API costs. If you feed 50 raw code files into an LLM, it often hallucinates or forgets the middle files (Context Collapse).

To solve this, I built a deterministic parsing step in the Node.js backend. Instead of sending raw code, the backend uses regex and string parsing to extract a lightweight "architectural summary" (e.g., identifying routes, database calls, and missing middlewares). This tiny string is what gets sent to the AI, ensuring instantaneous, accurate, and cheap responses.

The second major challenge was managing my OpenAI usage limits without the hackathon credits. Strategically hot-swapping between GPT-5.5 for boilerplate and GPT-5.6 for heavy reasoning allowed me to cross the finish line.

What I learned

I learned how to build a neuro-symbolic pipeline—combining traditional deterministic software engineering with modern LLM reasoning. I also learned a massive amount about context window management and how to build cost-effective AI tools that don't rely on dumping massive raw strings into an API. Finally, I proved that you don't need a massive budget to build a production-ready AI product if you engineer the prompt pipeline correctly.

Built With

• 5.6-terra
• codex
• express.js
• gemini
• gpt-5.5
• gpt-5.6
• nextjs
• node.js
• openai
• react
• systemdesign
• tailwind