OwnYourCode

OwnYourCode helps students and junior developers understand their projects, create new ones, learn how the code works, and improve the skills they lack.

Comment

Inspiration

A lot of students and junior developers can build surprisingly complex projects with AI, but there is a problem: the application may work even when the person who created it does not fully understand the code.

I experienced this myself while building with AI. It is easy to ask a model to generate a feature, fix an error, or connect a frontend to a backend. It is much harder to explain why the architecture works, where validation happens, what the security limitations are, or how to modify the project without depending completely on AI.

That problem inspired OwnYourCode.

The main idea is simple:

AI may help you build the code, but OwnYourCode helps you understand, verify, and defend it.

What OwnYourCode does

OwnYourCode turns a software project into a personalized learning experience.

A learner can provide a public GitHub repository, and the application performs a bounded repository inspection. It detects confirmed technologies, languages, manifests, and architecture evidence without cloning the repository or pretending to understand files it has not inspected.

From that evidence, OwnYourCode creates a guided learning flow:

  1. Inspect the repository
  2. Learn how its architecture works
  3. Complete an evidence-based assessment
  4. Solve a verified coding lab
  5. Repair a security configuration challenge
  6. Defend architecture decisions
  7. Review a transparent learning summary

The AI is used for explanation and evaluation where human language matters. Deterministic validation remains authoritative for code structure, fixed checks, evidence selection, and completion gates.

The public demo is session-only and can be tried without creating an account.

Signed-in users can also save projects, return after a refresh or logout, archive projects, and resume a persisted Existing Repository learning workspace. New Idea projects can already be stored, with a larger Build From Scratch learning workflow planned next.

How I built it

OwnYourCode is a full-stack application built with:

  • React, TypeScript, and Vite for the frontend
  • FastAPI and Python for the API
  • PostgreSQL and SQLAlchemy for persistent data
  • Alembic for database migrations
  • Clerk for authentication
  • Docker Compose for the local environment
  • GitHub APIs for bounded public repository inspection
  • OpenAI models for evidence-grounded lesson generation and explanation evaluation

The application follows a modular-monolith architecture.

The frontend sends validated requests to FastAPI. The backend validates them with Pydantic, verifies the authenticated user, scopes saved projects by owner, and performs the repository or learning operation.

Repository evidence is collected deterministically before it is sent to the model. Model output is structured and validated again before it is returned or persisted.

For the coding labs, learner code is parsed using Python's AST. It is never executed inside the API process. The security challenge also uses a server-owned teaching fixture and does not claim to scan the actual repository.

Persistent learning workspaces use immutable inspection snapshots, versioned learning definitions, saved attempts, context fingerprints, idempotency protection, and server-calculated progression.

How I used Codex

I used Codex as an implementation partner throughout the project, including GPT-5.6 for part of the build.

My role was to define the product, architecture, safety boundaries, user experience, and acceptance criteria. I reviewed implementation plans, tested the application in the browser, found integration and UX bugs, and repeatedly refined the generated code.

Some examples include:

  • separating AI explanation from deterministic verification;
  • preventing arbitrary learner-code execution;
  • designing ownership checks for persisted projects;
  • identifying scrolling, CORS, form-control, and stage-progression bugs;
  • restructuring the interface from one long page into a staged learning workspace;
  • preserving the public demo while adding authenticated persistent projects.

Codex accelerated implementation, but the product direction, trade-offs, testing, and final decisions remained my responsibility.

Challenges

One major challenge was preventing the application from making unsupported claims about a repository. The solution was to create a bounded evidence catalog and require generated lessons and evaluations to reference only confirmed evidence IDs.

Another challenge was designing practical verification without running arbitrary code. I solved this with constrained server-owned fixtures and AST-only validation.

Authentication and persistence introduced additional complexity. Every protected project query has to be scoped to the authenticated owner, migrations must remain reproducible, and learning progress must survive refreshes without trusting completion flags sent by the browser.

The frontend also required several iterations. Early versions were one long scrolling page. I redesigned the flow into focused stages with explicit Continue and Back actions, fixed unwanted scrolling, improved accessibility, and created a more polished liquid-glass visual system.

What I learned

This project taught me that building with AI is not only about writing prompts.

I learned how to think about:

  • frontend and backend boundaries;
  • API validation;
  • authentication and authorization;
  • database migrations and ownership;
  • model-output validation;
  • idempotent requests;
  • deterministic versus model-based evaluation;
  • safe code analysis;
  • accessibility and real browser testing.

Most importantly, I learned that working software is not the same as understood software. That is the exact problem OwnYourCode is trying to solve.

What's next

The next step is to expand saved projects into deeper multi-module learning paths.

Existing Repository projects will receive several practical modules based on confirmed repository evidence. New Idea projects will become guided Build From Scratch experiences with architecture decisions, milestones, practical tasks, verification, and a final defense.

The long-term goal is not to stop developers from using AI. It is to help them remain the engineers responsible for what AI helps them create.

Built With

Share this project:

Updates