Nexus

Landing Page UI
Landing Page UI
Nexus Dashboard

Inspiration

We were inspired by the no-code era where AI generated code is dominating the trend, and we decide to push it further by removing most of the prompting work by automating the whole pipeline of developing projects. We experience that most of our time is spent on thinking of ideas, features, debug,... and try to prompt accurately to the LLM to achieve it. So we built this platform not only for automatic feature suggestion across the codebase, but also auto building it from planning, a test-first approach for less error-prone, and auto creating a pull request on github. Every developer's work is automated.

What it does

Nexus is an AI-powered platform that connects to a GitHub repository and autonomously takes a feature from idea to pull request. It starts by cloning the repo and analyzing the full file tree, classifying files by role and summarizing key code to build a structured digest of the codebase. Using a two-pass LLM pipeline, it constructs a feature graph, a hierarchical visual map of user-facing product features grounded in actual source code, not conventions or guesses. From any node in the graph, Nexus surfaces contextually relevant suggestions for what to build next, filterable by complexity and custom criteria. When a user selects a feature, OpenAI generates a detailed step-by-step implementation plan and a test file, which the user can review and revise before approving. Once approved, Nexus invokes Claude Code CLI headlessly inside an isolated sandbox, which autonomously reads the plan and implements the feature including writing, editing, and creating files across the full stack. After implementation, it runs the project's own test suite and feeds failures back to Claude for iterative fixing. Finally, all changes are committed to a new branch and a structured pull request is opened on GitHub, delivering a working, connected, tested implementation ready for human review.

How we built it

We built Nexus as a modern AI-native full-stack system designed for autonomous software development. The frontend is built with Next.js, providing an interactive feature graph interface and real-time execution monitoring. The backend runs on FastAPI, orchestrating repository analysis, AI planning, execution control, and GitHub automation. We use Supabase as our managed Postgres database for storing repository metadata, execution state, and streaming logs in real time. At its core, Nexus combines multiple AI systems in a structured pipeline. We use a multi-stage analysis approach to understand the repository at a product level, extracting meaningful feature structures grounded in actual source files. This powers a visual feature graph that developers can explore and expand. For execution, Nexus uses a secure sandbox model. Every run operates inside an isolated environment where the repository is cloned and modified safely. AI-generated plans are transformed into tested implementations through a structured build pipeline that includes automated test execution, verification, and iterative refinement. Finally, Nexus integrates directly with GitHub, committing changes to a new branch and automatically opening a structured pull request, delivering production-ready, reviewable code. Throughout development, we focused heavily on reliability, modular architecture, and safe AI orchestration, ensuring autonomous execution without compromising code integrity.

Challenges we ran into

The hardest problem we solved was plan-to-code mismatch, in which OpenAI generates plans from file summaries, not full source, so it routinely misses wiring: a service function never exposed via a route, props collected but never passed, response shapes that don't match. We addressed this with a post-verification wiring check: a read-only Claude pass that traces the full user journey and outputs a structured gap list, followed by one targeted Claude invocation per gap scoped to only the files mentioned in the gap description, preventing timeout and scope creep. Throughout the build we iterated on prompt engineering heavily, moving from single-pass to two-pass feature extraction, adding few-shot examples, and hardening instructions to eliminate hallucinated features and architectural noise.

Accomplishments that we're proud of

We are most proud of building a fully autonomous, end-to-end feature pipeline that goes beyond code generation and into execution integrity. Nexus does not stop at suggesting ideas or drafting files; it plans, implements, verifies, iterates, and delivers a structured pull request that integrates cleanly into an existing repository.

What we learned

We learned how to invoke Claude Code CLI in headless mode via subprocess, streaming its stream-json output in real-time, parsing assistant messages, tool calls, and results line by line to surface live build logs to the frontend while Claude works autonomously in the background.

We learned how to design a graph data structure for product features where nodes represent user-facing capabilities rather than architectural layers, and edges encode dependency and compositional relationships, and that the framing of your LLM prompt determines which of those two things you get.

What's next for Nexus

The next most ambitious frontier is that we want Nexus to be able to learn from previous builds tracking which feature was built, how many successes and failures there were, and which part it struggled the most for continuously improving its quality with better planning, better feature graph accuracy.