HypoTrace

HypoTrace is a private AI coding coach that learns your recurring reasoning mistakes, predicts them before they happen, and gives the smallest useful intervention to help you improve.

Comment

Inspiration

I've noticed that coding tools are very good at completing code, but they do not always help a student understand why they keep making the same mistakes. A developer may repeatedly miss a colon, make an index error, misunderstand an algorithm, or write a test with the wrong expected result. HypoTrace was inspired by the idea of a personal learning coach inside VS Code. Instead of only fixing one error, it tries to notice patterns across real coding attempts and help the developer improve over time.

What it does

HypoTrace is a private AI coding coach for VS Code. It observes normal code runs in the VS Code terminal and saves only privacy-filtered learning signals, such as an error category and whether a later run succeeded. It does not store raw code, terminal history, secrets, or API keys in its learning database. The extension can:

  • Track failed and successful code runs in each project.
  • Notice repeated mistake patterns, such as repeated syntax errors or assertion failures.
  • Keep separate views for the current project and the developer’s all-time profile.
  • Show simple charts for progress, strengths, areas to improve, and project issues.
  • Use Agent A to suggest possible reasons for a repeated mistake.
  • Use Agent B to show what evidence could prove that reason wrong.
  • Create a forecast only when there is enough similar past evidence.
  • Offer a small coaching question and measure the next matching run instead of assuming the question helped.
  • Show how saved runs, patterns, possible reasons, forecasts, and checks are connected.

How we built it

I've built HypoTrace as a VS Code extension with a local Python backend. The VS Code extension watches normal integrated-terminal runs, recognizes broad error outcomes, and sends privacy-filtered semantic information to the local backend. The backend uses SQLite to keep the developer’s personal learning history on the local machine. I've used an LLM through the OpenAI API for plain-language project assessments, possible explanations, counterevidence, and short coaching prompts. The dashboard is a responsive VS Code webview with animated charts, project tabs, a forecast tab, and a local “Start fresh” option. The backend starts locally on an available port, so the user does not need to host a server.

Challenges we ran into

One challenge was making the system useful without making it annoying. A warning should not appear every time a developer opens a file or makes one small error. I designed HypoTrace to rely on completed run outcomes and repeated comparable evidence before showing a forecast. Another challenge was privacy. I wanted the project to learn from coding behavior without saving sensitive code, .env files, secrets, or raw terminal logs. I also faced practical engineering issues, including local server port conflicts, SQLite locking, dashboard responsiveness, stale extension versions, and keeping current-project data separate from all-time data.

Accomplishments that we're proud of

I am proud that HypoTrace is more than a code-completion tool. It has a complete learning loop: Normal code run -private semantic outcome -repeated-pattern detection

  • possible explanations and counterevidence
  • forecast
  • small coaching action
  • later run measures the result I'm also proud of the privacy-first design. The system keeps its learning data locally and focuses on semantic outcomes instead of storing a developer’s raw code. Finally, I built a dashboard that makes technical information easier to understand through project-specific views, all-time growth views, forecasts, charts, and clear language.

What we learned

I've learned that personal AI systems need more than an LLM response. They need memory, evidence, uncertainty, and feedback from real outcomes. I've also learned that a good AI coach should not pretend to know everything. A possible explanation is not a fact. That is why HypoTrace shows what could prove an AI suggestion wrong and waits for later evidence. Most importantly, the best developer tool should make the developer stronger, not more dependent on the tool.

What's next for HypoTrace

Next, I want to improve the research side of HypoTrace by building stronger multi-minute problem-solving sessions, better clustering of similar mistakes, and more accurate personalized forecasts. I also plan to add deeper transfer and retention testing. For example, if a developer fixes an idea in one project, HypoTrace should check whether they can use that lesson later in a different kind of problem. In the future, HypoTrace can become a complete long-term learning companion for developers: private, evidence-based, less interruptive over time, and focused on helping people become better problem solvers.

Built With

Share this project:

Updates

Submission history