Project Info

Skribez AI Writing Assistant

This project did not submit a demo video on Devpost.

Inspiration

As students ourselves, we noticed a gap: current AI tools either write for you or leave you hanging. We wanted something in between - an assistant that helps you think, draft, and revise, but doesn’t take over. So we built Skribez: an AI-enhanced writing tool that supports student agency.

What it does

Skribez is an AI-enhanced writing environment built for students. It has two main components: Text Editor (left side): A clean, markdown-friendly word processor with formatting tools and image support. AI Assistant (right side): A dual-mode assistant that supports writing in two ways: Ask Mode: For conceptual questions, quick lookups, and research help. Edit Mode: For in-context rewriting, edits, and exploratory drafting - inspired by developer tools like Cursor, but tailored for writing. The goal is to encourage autonomous writing while giving just enough smart support to help students explore, refine, and defend their ideas.

How we built it

Frontend: React + Lexical for a flexible, modern writing experience. Backend: FastAPI connected to two AI models via Anthropic APIs: Groq: Lightweight, fast, and ideal for answering simple questions or making small edits. Claude Opus: A heavier, more powerful model used for complex reasoning, nuanced edits, and deep research tasks. We built dynamic routing logic between the two, so the assistant knows when to escalate from Groq to Opus for better support - giving the best of both speed and intelligence.

Challenges we ran into

Building a clean yet powerful dual-mode AI assistant took some thought - especially around UX clarity. Getting Grok and Opus to play nicely together took tweaking, especially on fallback and redirect logic. Tuning the edit mode to feel natural without taking control from the writer required some iteration. Building our own text editor that supports edits from both people and AI agents

Accomplishments we're proud of

Created a truly agentic workflow for writers - not just an AI chatbot glued onto an editor. Leveraged Groq’s speed to deliver fast, seamless interactions while still enabling complex tasks with Opus. Built a tool that satisfies the need of a large userbase.

What we learned

Students don’t want full essays - they want someone smart to bounce ideas off and help polish their own. Groq, while lightweight, is surprisingly capable when used intentionally and paired with the right fallback strategy.

What's next

Media Management: Inserting and editing graphs, videos, and more dynamic content inside essays. Assignment Integration: Connect with platforms like Canvas via API to allow students to work directly on their coursework. Reaching out to universities for collaboration. More Personalization: Let users adjust how much help they want from AI and in what form — hints, edits, questions, etc.

Writing Tool for Students

An AI-enhanced writing interface that supports students throughout the writing process without taking away their agency.

Features

Text Editor (Left Side): A standard word processor with typical formatting tools, markdown support, and image insertion
AI Chat Assistant (Right Side): Interactive chat window for brainstorming ideas, getting writing suggestions, and receiving feedback

Tech Stack

Frontend: React with Vite
- Text Editor: Lexical (Meta's extensible text editor framework)
- Styling: CSS
Backend: FastAPI (Python)

Project Structure

├── frontend/           # React frontend application
│   ├── public/        # Static assets
│   │   ├── components/  # React components
│   │   │   ├── Editor/  # Text editor components
│   │   │   ├── Chat/    # Chat interface components
│   │   │   └── Layout.jsx
│   │   ├── styles/      # CSS files
│   │   ├── App.jsx      # Main app component
│   │   └── main.jsx     # Entry point
│   └── package.json     # Frontend dependencies
│
├── backend/           # FastAPI backend
│   ├── app/          # Application code
│   │   ├── main.py   # FastAPI app
│   │   └── routers/  # API routes
│   └── requirements.txt
│
└── README.md

Getting Started

Backend Setup

Navigate to the backend directory:
```
cd backend
```

Create a virtual environment:

python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

Install dependencies:
```
pip install -r requirements.txt
```
Run the backend server:
```
uvicorn app.main:app --reload
```

Frontend Setup

Navigate to the frontend directory:
```
cd frontend
```
Install dependencies:
```
npm install
```
Run the development server:
```
npm run dev
```

The application will be available at http://localhost:5173

Development Notes

This is a starting version with placeholder AI functionality
The text editor uses Lexical for rich text editing capabilities
The chat interface is ready for AI integration but currently returns placeholder responses

Analysis

Compare with all teams

View

Metric

Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.

Technology

Found in codeClaimed only

AnthropicIn code
CSSIn code
FastAPIIn code
HTMLIn code
JavaScriptIn code
PythonIn code
ReactIn code
MongoDBClaimed
VercelClaimed

7 of 9 appear in the indexed code. 2 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.

AI coding agents

No AI coding agent signals were found in this repository.

Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.

Codebase size

Source size

297 KB

Source files

Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.