Buildie

Build-in-Public on Autopilot

Comment

Inspiration

Building in public has exploded as the go-to growth hack for devs and startups who need visibility—but cranking out social posts and demo videos for every feature is a grind. Buildie fixes that: it watches your GitHub commits, uses an LLM to spot shipped features, spins up an agent to draft tweet threads and record demo clips, and even posts them straight to Twitter—no extra work required.

What it does

  1. Watch: A GitHub webhook notifies Buildie whenever there’s a new commit.
  2. Detect: An initial OpenAI LLM analyzes the diff to decide if it qualifies as a “shipped feature.”
  3. Generate: A LangGraph agent then:
    • Parses the code diff
    • Crafts a Twitter-thread draft (headlines, bullet points, hashtags)
    • Drives a browser-use agent to record a 5–10 second demo clip
  4. Post: Direct integration with the Twitter API to publish your thread + demo in one click.
  5. Review: All generated content appears in a simple chat-style UI where you can edit, re-generate, or post.

How we built it

  • Backend (FastAPI):
    • GitHub webhook listener & “feature shipped?” logic
    • LangGraph agent orchestration endpoints
    • Supabase for authentication, diff storage, drafts, and event streaming
  • LLM Orchestration (LangGraph):
    • A single agent that reasons over code diffs, generates social copy, and triggers the browser-use agent
  • Browser-use Agent:
    • Headless browser interactions to navigate to the changed UI and capture a concise demo clip
  • Frontend (Next.js + TypeScript):
    • Chat-style event stream UI
    • Editable tweet-thread component
    • Built-in “Post to Twitter” button using the Twitter API

Challenges we ran into

  • Feature-Completion Detection: Teaching the LLM to reliably know when “this diff matters.”
  • RAG over a Live Codebase: Keeping retrieval-augmented context fresh so the agent sees the right code snippets.
  • Prompt Engineering: Iterating prompts to balance technical accuracy with engaging, on-brand voice.
  • Browser-Agent Stability: Finding robust selectors and timing to capture consistent demo clips.
  • Async Coordination: Ensuring the LLM agent, webhook events, and browser-use agent hand off data without duplication or loss.
  • Monorepo Complexity: Managing shared types and utilities across /api and /web without slowing down local development.
  • UX Simplicity: Designing an intuitive flow so anyone can review and post without wading through raw event logs.

Accomplishments that we’re proud of

  • 🤖 Built a LangGraph agent capable of end-to-end reasoning over code diffs.
  • 📹 Developed and integrated a browser-use agent for automated demo recording.
  • 🌱 Assembled a full-stack proof-of-concept (FastAPI + Next.js + Supabase + LangGraph) that demonstrates the core vision.

What we learned

  • Full-stack agent orchestration demands clear contracts between services (webhooks ↔ API ↔ agent ↔ UI).
  • Tiny prompt tweaks can make or break LLM reliability—invest in iterative prompt design.
  • Async workflows require idempotent operations and robust error handling to stay sane.
  • Integrating a browser-use agent unlocks powerful demos but comes with its own flakiness.

What’s next for Buildie

  • Go Live: Set up CI/CD pipelines and deploy Buildie to production.
  • Harden Browser-Agent: Improve stability and reliability of the browser-use agent for flawless demos.

Built With

Share this project:

Updates