Visible

Devs spend hours building and zero explaining. Visible turns commits and code into clear, user-facing updates, straight from the termina,l so features don’t die hidden. You ship. We make it visible.

Comment

Inspiration

We realized that 39% of SaaS founders are solo entrepreneurs. They are incredible at coding but often struggle with communication. We noticed a recurring pattern in our own lives and the community: developers spend 20 hours building amazing features but 0 hours explaining them to their users.

Features are shipped and then die in obscurity because nobody knows they exist. While tools like Jira know a task is "Done," they cannot explain the value of that task to a final user. We wanted to bridge the gap between shipping code and shipping value, automating the one part of the job devs hate the most: writing marketing updates.

What it does

Visible is an AI Agent that translates raw code into user-friendly communication.

  1. Capture: The developer runs visible analyze in their terminal. The CLI captures local commits and code diffs.
  2. Analyze: Our Agent (powered by LLMs) analyzes the actual code changes—not just the commit messages—to understand the context and impact of the feature.
  3. Generate: It instantly generates three types of updates in a web dashboard:
    • User-facing: Friendly, benefit-driven text for emails or in-app notifications.
    • Changelog: Technical but clean points for documentation.
    • Social: Short, engaging posts ready for Twitter/X.
  4. Distribute: The developer can copy the text or send it directly via email integrations (Resend).

How we built it

We built Visible as a full-stack Javascript application designed for speed and developer experience:

  • CLI: Built with Node.js and Commander.js to interact directly with the user's local git history.
  • The Brain: We used Next.js API Routes connected to OpenAI. The core challenge was Prompt Engineering—teaching the model to read a raw git diff and extract the "marketing value" without getting lost in syntax.
  • Frontend: A clean dashboard built with Next.js and shadcn/ui to display the generated updates.
  • Storage: For the MVP, we utilized local JSON file storage to ensure the CLI and Dashboard could communicate instantly on the local machine without complex cloud deployment overhead.
  • Integration: We implemented Resend to allow users to email their updates directly from the dashboard.

Challenges we ran into

  • Scope Creep: Initially, we wanted to generate release videos automatically. We realized halfway through that getting the text perfect was more valuable than a mediocre video. We had to pivot quickly to a "Text-Only" MVP to ensure quality.
  • Context Windows: Feeding large code diffs into an LLM is tricky. We had to optimize how we parse git logs to ensure we give the AI enough context to be accurate without overloading the token limit.
  • The "So What?" Factor: It was hard to tune the AI to stop sounding like a developer ("Refactored API controller") and start sounding like a marketer ("Made the app 2x faster").

Accomplishments that we're proud of

  • The "Magic" Moment: Running visible analyze in the terminal and seeing a perfectly written marketing blurb appear on the web dashboard seconds later feels magical.
  • End-to-End Flow: Despite the time pressure, we managed to connect the CLI, the AI analysis, and the frontend Dashboard into a seamless loop.
  • Solving a Real Problem: We aren't just making a toy; this solves a pain point that costs the industry roughly 15-25% of engineering capacity (lost in documentation/communication gaps).

What we learned

  • Diffs > Commit Messages: We learned that developers write terrible commit messages. To generate good content, the AI must read the code changes, not just the human descriptions.
  • The Power of Niches: By focusing specifically on "Solo Devs / Indie Hackers," we were able to design a workflow (CLI-first) that fits perfectly into their existing habits.
  • MVP Discipline: Cutting the video generation feature was painful but necessary. It taught us that a polished simple tool is better than a broken complex one.

What's next for Visible

We have a clear roadmap to take Visible from a Hackathon project to a SaaS product:

  1. GitHub Integration: Moving from a local CLI to a GitHub Webhook, so updates are drafted automatically when a PR is merged.
  2. Real Social Integration: Connecting directly to Twitter/X and LinkedIn APIs so users can post with one click (instead of copying and pasting).
  3. Public API: Allowing other tools to send context to Visible for analysis.
  4. Video Generation: Re-introducing the video feature once the text engine is perfected (v5).

Built With

  • commander.js
  • langchain
  • langgraph
  • next.js
  • open-ai
  • resend
  • shadcn/ui
  • typescript
Share this project:

Updates