OwnIt

Inspiration

AI coding agents can generate working code faster than ever, but working code does not necessarily mean the developer understands it. When developers accept AI-generated implementations, they can struggle to explain function relationships, predict the impact of changes, or know whether their understanding is still valid after another edit.

I built OwnIt around a simple idea: if developers are going to ship AI-generated code, they should be able to explain it.

What it does

OwnIt transforms a Python repository into a set of structural comprehension quizzes. Instead of asking an LLM to invent questions and evaluate answers, OwnIt uses static analysis to derive questions and expected answers from the repository's call graph.

It currently supports:

• Callee questions: Identify which functions a function calls directly.
• Impact questions: Determine which functions could be affected by a change.
• Call-chain questions: Find the shortest call chain between functions.
• Function cards: See how many functions call a function and how many it calls.
• Source-backed grading: Evaluate answers against statically derived facts and display supporting code evidence.
• Understanding validity: Track whether a question remains valid when the code it depends on changes.
• Proof checks: Verify claims through the Proof tab and scripts/verify.sh, with results written to results/.

When static analysis cannot resolve a relationship confidently, OwnIt excludes it rather than presenting speculation as fact.

How I built it

I built OwnIt in Python, using the standard library without external packages, API keys, or LLM dependencies. Its analysis is based on the structure of the actual repository rather than generated explanations.

The application analyzes function relationships to construct a call graph, derives questions from supported relationships, and evaluates answers against the corresponding structural facts. Its local server and command-line interface let developers scan a project and interact with the resulting quiz through a browser.

The project is designed to run with Python 3.10 or newer.

Challenges I faced

One of the central challenges was keeping questions trustworthy. Python supports dynamic behavior, unresolved attributes, and ambiguous names, making it risky to assume that every apparent function relationship is correct. OwnIt therefore excludes uncertain relationships from question generation.

Another challenge was ensuring that a question remains meaningful as the underlying code evolves. A correct answer can become outdated after a function changes, so OwnIt connects questions to the code they depend on and tracks whether that understanding remains valid.

I also wanted the project to work without an external AI service. Using deterministic static analysis makes the grading reproducible, keeps the repository local, and removes API costs and model-generated evaluation errors from the core workflow.

What I learned

Building OwnIt reinforced that effective AI-assisted development is not just about generating code. It is also about verification, traceability, and maintaining an accurate mental model of a software system.

I explored how static analysis can turn code structure into useful learning experiences, why uncertain results should be excluded rather than guessed, and how code changes can invalidate previously correct assumptions.

What's next

OwnIt explores a different side of AI-assisted software engineering: helping developers remain accountable for the code they ship. The goal is to make understanding part of the development workflow, rather than something developers discover they lack when debugging or modifying an unfamiliar codebase.

Built With

• cli
• css3
• html5
• javascript
• python