Current

Instantly Turn Customer Feedback to Developer-Approved PR's

Comment 1

GitHub Link: https://github.com/kevskillz/treehacks2026

Inspiration

Modern software teams are flooded with product feedback on X posts, DMs, texts, support calls, and community threads. But despite how public and high-signal that feedback can be, turning it into clean, testable code changes is still slow and manual: someone has to interpret the request, clarify details, translate it into a scoped task, implement it safely, and then package it into a PR with tests and a preview.

We built Current because we wanted to close that gap. The idea is simple: if your users are already telling you what to build on X, why not let that feedback flow directly into your codebase, with you still in full control at every step?

What it does

Current is an end-to-end feedback-to-code pipeline that takes raw user feedback from X and turns it into sandbox-tested, preview-ready pull requests with explicit developer approval at every stage.

  1. Poke notifies the developer of new feedback from the community:
    • a. X Replies — A Grok agent monitors replies and likes, DMs users as the developer to gather context, and scores feedback by engagement.
    • b. Customer Service Voice Agent — Users call a Twilio + ElevenLabs phone-number to submit feedback via voice/SMS.
  2. All feedback is stored in Supabase and shown in the Frontend App with engagement metrics.
  3. The developer approves, rejects, or edits feedback from the dashboard or via SMS through Poke.
  4. On approval, the Build Server creates a GitHub issue enriched with codebase-specific file references using GPT-5 Mini.
  5. GPT-5 Mini generates an implementation plan. The developer reviews and approves it.
  6. Modal spins up a sandboxed cloud VM. OpenAI Codex CLI (Codex-Mini-5.1) generates test cases first, then implements the code changes.
  7. Automated verification runs tests, build, linters, and a self-review scored 0-100. If anything fails, it iterates up to 3 times.
  8. The Build Server commits, pushes the branch, and opens a PR with results. Vercel deploys a preview URL.
  9. The developer receives the PR summary + preview link through Poke for final review.

How we built it

The system is split across four main services, all coordinated through Supabase as a central state engine:

X Server (Flask):

  • main.py - X Account Activity API webhooks, OAuth 2.0 PKCE authentication, mention polling, and DM handling
  • Grok integration for generating project titles and descriptions from raw tweet text
  • Automatic DM follow-ups to tweet authors for clarification

Build Server (FastAPI):

  • main.py - Core orchestrator with background status poller
  • coder.py - OpenAI Codex CLI workflow orchestration with NDJSON streaming
  • modal_sandbox.py - Modal cloud VM provisioning with pre-built Docker images (Python 3.12, Git, GitHub CLI, Codex CLI)
  • llm.py - GPT-5 Mini for plan generation, tech stack detection, and issue enrichment
  • github_client.py - GitHub issue and PR management via gh CLI running inside sandboxes
  • testing.py - Automated repo context detection and test verification across multiple frameworks

Frontend App (Next.js + Supabase):

  • Next.js 15 with App Router and Server Components
  • Supabase SSR for authentication and real-time data
  • shadcn/ui + Tailwind CSS for the developer dashboard
  • Automation queue with engagement metrics, plan review interface, and status timeline

Poke Integration:

  • Developer notifications for incoming feedback, plan approvals, and PR completions
  • SMS-based approval flow so developers can approve or reject directly from their phone

AI Models:

  • GPT-5 Mini - Plan generation, issue enrichment, tech stack detection, tweet aggregation
  • OpenAI Codex CLI (Codex-Mini-5.1) - Code implementation in headless auto-approve mode

Challenges we ran into

The Modal pipeline was slow at first because each run spun up a fresh environment and installed all project dependencies from scratch. We solved this by pre-building a Docker image with Git, GitHub CLI, and Codex CLI baked in, so the sandbox only had to clone the repo and apply changes.

Getting the X API OAuth flow working was also tricky. The webhook CRC challenge validation and the difference between OAuth 1.0a (for account activity) and OAuth 2.0 PKCE (for posting and DMs) took some debugging before everything clicked.

Accomplishments that we're proud of

We're proud of the breadth of integration: X, Grok, OpenAI Codex, Supabase, Poke, Modal, GitHub, Vercel, Twilio, and ElevenLabs all working together as one cohesive pipeline. The fact that a tweet reply/phone call can flow all the way through to a tested PR with a live preview, with the developer in control the entire time, feels like a genuine step forward for building in public.

What we learned

This was our first time working with the X API, xAI SDK, and OpenAI Codex CLI. Grok handles tweet classification and feedback aggregation on the X side, while GPT-5 Mini and Codex CLI handle plan generation and code implementation. We also learned a lot about designing state-driven multi-agent systems where every service reads from and writes to a single source of truth, which keeps the whole pipeline observable and debuggable.

What's next for Current

We want to make Current easy to install through a simple sign-up flow where developers connect their GitHub repository and everything is automatically provisioned. The goal is to reduce setup to just a few clicks so any team can plug into the feedback-to-PR pipeline without manual configuration.

Built With

Share this project:

Updates