ContextPack

ContextPack turns messy project context into a trustworthy handoff that shows what’s known, unresolved, missing, and what the next human or AI should do next.

Comment

Inspiration

AI-assisted projects often become scattered across chats, coding agents, notes, TODOs, and half-finished decisions.

The problem is not only losing information — it is losing the distinction between what was actually decided, what is still unresolved, and what information is still missing.

Traditional summaries can compress context, but they often blur those differences.

I wanted to build a focused handoff tool that helps another human or AI continue a project without guessing.

That became ContextPack.

What it does

ContextPack turns messy project context into a structured seven-section handoff:

  1. Goal
  2. Current State
  3. Key Decisions
  4. Constraints
  5. Open Questions
  6. Missing Context
  7. Next Actions

The main idea is to separate:

  • what is confirmed
  • what is unresolved
  • what is missing
  • what should happen next

For example, if the input says:

maybe supabase?

ContextPack keeps Supabase as an Open Question instead of treating it as a confirmed decision.

If the input says:

deploy friday

ContextPack can identify Friday as a constraint while also surfacing that the exact calendar date is missing.

It also avoids inventing relationships between unrelated notes. For example, john still checking pricing should not become “John is checking Supabase pricing” unless the source context actually says that.

Users can copy the result as Markdown or use Copy for AI to create a continuation-ready handoff for another AI tool.

How I built it

ContextPack is a lightweight web application built with:

  • Vite
  • Vanilla HTML
  • Vanilla CSS
  • Vanilla JavaScript
  • Vercel Serverless Functions
  • OpenAI JavaScript SDK
  • OpenAI-compatible Chat Completions
  • JSON Schema structured output
  • Zod validation

The frontend collects:

  • an API endpoint
  • an API key
  • an exact model ID
  • an optional Thinking / Reasoning level
  • project context

The backend sends the request to an OpenAI-compatible provider and asks for a strict structured response.

The returned JSON is then validated again with Zod before it is rendered.

ContextPack uses a provider-agnostic BYOK approach, so it does not hardcode one AI provider or model.

The deployed version was tested successfully with NVIDIA NIM.

Challenges I ran into

The hardest part was not generating structured output — it was making the output trustworthy.

Early versions sometimes connected separate notes that were not actually related.

For example:

maybe supabase?

and

john still checking pricing

could incorrectly become a statement about Supabase pricing.

There was also duplication between Open Questions and Missing Context, where the same unresolved issue could appear in both sections.

I improved the system prompt with stronger rules around:

  • source grounding
  • conservative inference
  • no duplication
  • time and sequence grounding

Another challenge was provider compatibility.

OpenAI-compatible APIs do not always support exactly the same features, especially structured output and reasoning parameters, so ContextPack returns compatibility errors instead of silently changing the request.

Accomplishments that I'm proud of

I am most proud that ContextPack became more than a generic summarizer.

The demo input contains ambiguity, tentative decisions, missing information, and unrelated fragments.

ContextPack can correctly:

  • keep Supabase as an open question
  • separate pricing from Supabase
  • detect the missing exact Friday deployment date
  • distinguish confirmed decisions from unresolved items
  • generate actionable next steps

I also kept the project intentionally small.

There are no accounts, dashboards, databases, or saved credentials.

The project stays focused on one workflow:

messy project context → trustworthy handoff

What I learned

One of the biggest lessons was that structured AI output is not only about having a schema.

A schema can guarantee the shape of the response, but it does not guarantee that the meaning is grounded in the source.

Prompt rules around evidence, uncertainty, and conservative inference were just as important as the JSON Schema itself.

I also learned that “OpenAI-compatible” does not mean every provider behaves exactly the same.

Provider compatibility has to be treated explicitly.

Finally, this project reinforced the value of keeping scope small and spending more time on the behavior that makes the product different.

What's next

The current version is intentionally a focused proof of concept.

Future versions could explore:

  • provider capability detection
  • structured-output compatibility modes
  • reusable project handoff history
  • integrations with repositories and coding agents
  • portable ContextPacks between different AI tools
  • native AI continuation workflows

The long-term idea is to make ContextPack a portable context layer between humans, AI assistants, coding agents, and project tools.

ContextPack doesn’t just summarize what happened. It shows what the next human or AI still needs to know.

Built With

Share this project:

Updates

Submission history