Roast My App Idea

Roast My App Idea is a full-stack AI orchestration platform that stress-tests startup and application ideas by running them through multiple specialized AI agents, each evaluating a different dimension of the idea, and combining their output into a single response.

I'm designing and building this project independently, end-to-end, from the NestJS backend and database schema to the multi-agent orchestration logic and the Next.js frontend that streams results back to the user.

A single AI response typically gives only one perspective on an application idea. The goal was to get more useful, well-rounded feedback by having multiple specialized agents evaluate an idea independently (some running in sequence, some in parallel) and to surface their combined output to the user as it becomes available, not after everything finishes.

• Coordinating agents that depend on each other's output (sequential) alongside agents that don't (parallel)
• Streaming partial results to the frontend as agents complete, rather than waiting for the full pipeline
• Keeping the backend modular enough that new agent types can be added without reworking the orchestrator
• Authentication and role-based access on top of an evolving API surface

I designed specialized AI agents that each independently evaluate a different aspect of an idea (for example, market viability, technical feasibility, competitive landscape), coordinated by an orchestrator that decides which agents can run in parallel and which need to run in sequence based on dependencies between their inputs and outputs.

The Next.js frontend sends a request to the NestJS API, which hands it to an agent orchestrator. The orchestrator runs the appropriate Claude-powered agents (in parallel where possible, sequentially where one agent's output feeds another) and streams results back to the frontend over Server-Sent Events as they become available.

• Modular NestJS architecture with separate Auth, Users, and Agents modules to keep responsibilities isolated
• JWT authentication with role-based guards protecting agent-invocation endpoints
• Server-Sent Events for streaming, chosen over WebSocket because the data flow is one-directional (server to client)
• PostgreSQL for persistence, with Drizzle ORM and TypeORM both used across different parts of the schema as the project evolves

• Designed the agent orchestration layer that coordinates sequential and parallel Claude agent pipelines
• Built the NestJS module structure for Auth, Users, and Agents
• Implemented SSE-based streaming from the orchestrator through to the frontend
• Built the Next.js streaming UI that renders agent output progressively

Coordinating sequential and parallel agents behind one streaming response

The core design problem was that not every agent can run at the same time (some agents need another agent's output as input), but forcing everything into a strict sequence would make the response slower than necessary. The orchestrator models each agent's dependencies explicitly, runs independent agents concurrently, and only sequences agents that actually depend on each other. As each agent finishes, its result is pushed onto the SSE stream immediately, so the frontend can render partial results instead of showing a single loading state until the entire pipeline completes.

• Users see the first agent's feedback almost immediately instead of waiting for the full pipeline
• New agent types can be added to the orchestrator without restructuring existing pipelines

• Next.js
• NestJS
• PostgreSQL
• Drizzle ORM
• TypeORM
• Claude API
• Server-Sent Events
• JWT

Designing the orchestrator's dependency model up front, deciding what can run in parallel versus what must be sequential, mattered more to the final user experience than any individual agent's prompt design.