Forge Landing Page
Forge Huddle
Forge Architectural Diagram

Forge: Where AI and Human Engineers Work Together

Inspiration

AI has made writing software faster than ever. Engineers can now generate features, refactor code, and build entire systems with a few prompts.

But there is a major catch. If nobody understands the code being created, teams lose ownership of their software.

We have all seen this happen. Someone opens a pull request, joins a standup, or enters a design discussion and realizes they cannot fully explain why the system works the way it does. The code exists, but the understanding is missing.

We built Forge to drag engineers back into the loop.

Forge was inspired by the idea of an AI teammate that acts as a peer rather than a replacement. Instead of just writing code invisibly or summarizing a meeting after it ends, Forge actively participates in live discussions to help teams understand, design, and improve their systems together.

User Story

Imagine a team debating whether to split their backend into microservices.

Normally, someone has to pause the conversation, open the IDE, search through folders, and try to map out the architecture from memory.

With Forge, the team can simply ask:

"Forge, how does this system work?"

Forge reads the repository, explains the architecture, and sketches a live diagram on a shared whiteboard while everyone watches. Engineers can ask follow-up questions, explore tradeoffs, and see exactly how proposed changes affect the existing system.

The goal is not for Forge to make decisions for the team. The goal is to give every engineer the context they need to make the right choice.

What We Built

Forge is an AI engineering teammate that joins meetings as an active participant.

It can:

Join engineering calls and listen for direct questions
Understand a codebase by indexing repositories and querying live source code
Speak naturally using low-latency streaming voice
Explain architecture through live, hand-drawn diagrams
Update existing diagrams dynamically as discussions evolve
Connect whiteboard boxes back to specific files and lines of code
Raise its hand when it notices a risky tradeoff or system bottleneck

Unlike traditional AI meeting assistants that only record audio and generate notes afterward, Forge collaborates in real time during the meeting itself.

How We Built It

Forge uses a decoupled frontend and backend architecture to keep services fast and independent.

Backend

The backend is built with Express and TypeScript. It handles:

Repository indexing and context generation
Communication with the Anthropic API
Agent orchestration and streaming responses
Text-to-speech generation through ElevenLabs
WebSocket signaling and meeting state synchronization

When Forge starts, it indexes a repository to create a structural digest for the agent's context. The AI also uses live, read-only tools to search, list, and read files, ensuring every answer is grounded in the actual codebase.

Frontend

The frontend is built with React, Vite, and TypeScript.

The core feature is a custom whiteboard engine. Instead of generating static images, Forge produces live drawing operations that animate stroke-by-stroke. This makes the explanation feel like a human engineer sketching on a physical whiteboard.

The frontend also manages:

Microphone input and speech handling
Captions and voice playback
Agent stream rendering
Shared whiteboard state syncing

Challenges We Faced

Preventing Diagram Overlap in a Dynamic Canvas

When an architecture diagram evolves in real time, the layout engine has to adjust dynamically based on conversational context. One of our biggest technical challenges was figuring out how to avoid nodes, connections, and service diagrams overlapping with each other as the conversation progressed. A static rendering approach fails the moment a participant asks a follow-up question that inserts a new service between existing layers. We solved this by implementing an algorithmic coordinate layout engine that recalculates spacing and shifts adjacent nodes gracefully whenever the system structure changes.

Balancing AI Responsiveness with Human Conversation

Building a real-time voice experience is difficult, but the real challenge was making Forge responsive while still giving room for the participants to talk to each other. If the AI agent is too aggressive, it cuts off team brainstorming sessions; if it is too passive, it fails to contribute value when needed. We had to implement a customized Voice Activity Detection loop and an "interrupt protocol." This allows Forge to differentiate between conversational chatter between human team members and direct prompts intended for the AI, ensuring it steps in exactly when called upon and immediately yields the floor when a human speaks up.

Scope Management: Feature Expansion vs. Refinement

During a fast-paced development cycle, it is easy to succumb to feature creep. A major challenge was finding a good balance of features to add and how much to refine existing features. We wanted to build everything from gesture tracking, for example, but we had to strictly prioritize the core user value: real-time visual collaboration. We chose to refine our core whiteboard design and repo-grounding tools to make sure the "magic moment" of live, stroke-by-stroke architecture mapping felt completely seamless, rather than shipping a dozen half-baked concepts.

What We Learned

As AI becomes better at generating software, understanding software becomes the actual bottleneck.

The best engineering teams will not be the ones that use AI to remove humans from the development loop. They will be the ones that use AI to help every engineer participate, understand, and build with complete confidence.

Forge is our attempt at building that future.