Cuttle

Analyzes problems and provided the right solution without worrying about losing progress.

Comment

Project Story

Inspiration

When we first started our programming journey there was a time where we didn't know how to use Git safely and because of that we continued developing on our local devices, and then when we tried to push to github there was a mismatch and we weren't able to push our code. And the terminal told us to pull the most recent version and when we did we lost everything we just developed and after that one of us desperately tried to find a method to bring back our lost progress. That is why one of the features in our application is a git history tracker, to be able to easily restore what was lost.

Additionally, as a student, we face various test especially related to coding, and most of the time we face errors, and by debugging those errors we learn a lot. However for some reason, some of my classmates don't seem to understand what's happening when I help them debug it, and that's another reason why we made the debugger, as it allows my classmates to see where they went wrong with their own hands.

What it does

Cuttle is an AI-powered desktop application that analyzes repositories, detects issues, and generates intelligent code patches with detailed explanations.

Its core features include:

  • Side-by-side patch viewer
  • Root cause analysis for detected issues
  • AI confidence and estimated regression risk
  • File-specific patch summaries
  • Human-readable explanations for every code change
  • Developer approval workflow before applying fixes
  • AI-generated bug detection and fixes
  • Offline demo mode for showcasing the application's capabilities without requiring API calls

Rather than replacing developers, Cuttle assists them by making every suggestion explainable and reviewable.

How we built it

Cuttle was built as a cross-platform desktop application using modern web technologies.

Frontend

  • React
  • TypeScript
  • Tailwind CSS
  • shadcn/ui

Desktop Framework

  • Tauri

AI Integration

  • Large Language Models (LLMs) for:
    • Bug detection
    • Root cause analysis
    • Patch generation
    • Code explanations

Development Workflow

The application scans a repository, sends relevant context to the AI model, generates a structured response, and presents the proposed patch inside an interactive review interface.

Instead of automatically applying changes, Cuttle keeps developers in control by requiring manual review and approval before modifications are made.

Challenges we ran into

One of our biggest challenges was designing a workflow that developers could trust.

Generating code is relatively straightforward with modern LLMs, but presenting those changes in a way that feels safe required significant iteration. We spent time improving how patches are displayed, how explanations are generated, and how confidence levels are communicated.

Another challenge was supporting an offline demonstration. Since hackathon judging environments may have limited or unreliable internet connectivity, we built an offline demo mode that showcases the application's workflow using pre-generated AI responses while preserving the complete user experience.

Balancing simplicity with powerful functionality was also difficult. We wanted Cuttle to remain approachable while still providing the information experienced developers expect during code reviews.

Accomplishments that we're proud of

We're proud that Cuttle goes beyond simple AI code generation.

Some accomplishments include:

  • Successfully creating an interactive AI code review experience.
  • Building a clean, modern desktop interface using Tauri.
  • Designing an intuitive patch review workflow.
  • Making AI suggestions explainable rather than opaque.
  • Implementing confidence estimates and risk indicators.
  • Creating an offline demo mode suitable for hackathon judging.
  • Delivering a polished user experience despite limited development time.

Most importantly, we built something that developers can actually imagine integrating into their daily workflow.

What we learned

Throughout this project, we learned that usability is just as important as AI capability.

A highly accurate AI suggestion isn't useful if developers don't understand or trust it. We discovered the importance of presenting information clearly, providing context, and giving users complete control over accepting changes.

From a technical perspective, we gained valuable experience working with:

  • Desktop development using Tauri
  • Modern React architecture
  • AI-assisted software engineering
  • Repository analysis
  • Prompt engineering
  • UI/UX design for developer tools

We also learned that building tools for developers requires careful attention to workflow, not just features.

What's next for Cuttle

Our vision is to evolve Cuttle into a complete AI software engineering assistant.

Future plans include:

  • Continuous repository monitoring
  • GitHub and GitLab integration
  • Pull request review automation
  • Multi-file refactoring suggestions
  • Automated test generation
  • Security vulnerability detection
  • Team collaboration features
  • Support for additional programming languages
  • Local LLM support for privacy-sensitive projects
  • Personalized AI recommendations based on coding style

Our vision is to evolve Cuttle into a complete AI software engineering assistant. Future plans include continuous repository monitoring, GitHub and GitLab integration, pull request review automation, automated test generation, security vulnerability detection, local LLM support for privacy-sensitive projects, and personalized AI recommendations based on a project's coding style. Our long-term goal is for Cuttle to become a trusted AI teammate that helps developers write better, safer, and more maintainable software.

Built With

Share this project:

Updates