Hakit

• 

  Plan review

• 

  Team capability

• 

  Tasks

• 

  Mission control

Inspiration

Friday night, we sat down to find an idea. After talking about what everyone was good at, we started throwing some ideas around, but nothing stuck. And that's when the idea for Hakit hit us. An app to help solve the exact problem we were facing. An app to help you figure out what ideas to pursue based on the collective experience of the group. An app that helps you form an idea, distribute work, and execute that idea, inside the tight timeframe a hackathon demands.

What it does

Hakit starts with a team. Your team. Sign up with your GitHub account, and invite everyone the same way. Hakit will analyze the skills and technical familiarity of each team member.

After onboarding, you can either bring in an idea or have Hakit help you find one based on your team's skills and any interests you may have. A refined idea turns into a plan, where Hakit uses a combination of AI and fixed algorithms to determine the feasibility of the project inside of the event's deadline given the team members' defined availability and sleep hours.

After the project's plan is decided, Hakit splits it into tasks and milestones, then assigns tasks to teammates based on their respective skillsets and past experience with different frameworks.

During development, Hakit tracks commits live, and links them to tasks when it can, automatically tracking progress. It can identify potential issues with the timeline, and suggest changes to the plan/tasks using AI. For instance, if the development of core code took longer than expected, Hakit can surface that and recommend the removal of a few auxiliary features to meet the deadline.

To accomplish these tasks, Hakit uses embedding models through inference provider HuggingFace, as well as using the Gemini API for more advanced AI text-generation steps.

How we built it

It certainly would have been nice if we had Hakit to build Hakit. We discussed the strengths of each team member, and divided the work accordingly. Each team member built in slices, asynchronously, employing the use of agentic harnesses like Claude Code and Codex.

┌─────────────────────────────────────┐
│              BROWSER                │
│          React 19 + Vite            │
└─────────────────┬───────────────────┘
                  │ HTTPS / WSS
                  ▼
┌─────────────────────────────────────┐
│          CLOUDFLARE WORKER          │
│              Hono API               │
└─────────────────┬───────────────────┘
                  │
     ┌────────────┼────────────┐
     │            │            │
     ▼            ▼            ▼
┌─────────┐ ┌──────────┐ ┌───────────┐
│ Durable │ │ Queues + │ │  Gemini   │
│ Objects │ │   Cron   │ │           │
├─────────┤ ├──────────┤ ├───────────┤
│  Live   │ │  Async   │ │   Plan    │
│ Updates │ │   Jobs   │ │  Drafts   │
└────┬────┘ └────┬─────┘ └─────┬─────┘
     │           │             │
     └───────────┼─────────────┘
                 │
     ┌───────────┴───────────┐
     │                       │
     ▼                       ▼
┌─────────────┐       ┌─────────────┐
│ Hugging Face│       │ GitHub App  │
│    Qwen3    │       │ Auth + Hooks│
│ Embeddings  │       │             │
└──────┬──────┘       └──────┬──────┘
       │                     │
       └──────────┬──────────┘
                  ▼
┌─────────────────────────────────────┐
│             PURE ENGINE             │
│                                     │
│       Makes Every Decision          │
└─────────────────┬───────────────────┘
                  │
                  ▼
┌─────────────────────────────────────┐
│        TIGER CLOUD POSTGRES         │
│                                     │
│       TimescaleDB + pgvector        │
└─────────────────────────────────────┘

• One deployable app: a single Cloudflare Worker serves the React app and the Hono API, written in TypeScript end to end.
• Shared contract: every endpoint is defined once with Zod and checked on both the client and the server.
• Real time: each project gets its own Durable Object, which pushes live updates over WebSockets.
• Background work: Cloudflare Queues and a cron job process webhooks, embeddings and adaptive re-planning.
• Data: Tiger Cloud Postgres, reached through Hyperdrive and Drizzle. TimescaleDB stores activity history and pgvector stores skill vectors.
• AI drafts, the engine decides: Gemini drafts plans as structured JSON. A deterministic engine then computes scores, task assignments, hours and the critical path. Skill matching: Qwen3-Embedding, served through Hugging Face, matches people to tasks by meaning.
• Fallbacks: templates stand in for Gemini and keyword matching stands in for embeddings, so the app keeps working when a provider fails.
• Integrations: a GitHub App handles sign-in and repo activity. A Claude Code plugin sends opt-in coding-agent activity to the team’s live view.
• Team process: four parallel workstreams, coordinated through a full mock mode so nobody had to wait on anyone else. Typecheck, lint and tests ran in CI on every pull request.

What's next for Hakit

Next, Hakit will support deeper integrations with coding agents, so that it can allow coding agents to understand the project as a whole, as well as what teammates are working on. We already support monitoring agents' progress from Hakit.

Hakit can also be easily extended to support small team sprints, which are essentially what hackathons are anyway.

Built With

• cloudflare
• gemini
• github
• huggingface
• typescript