https://github.com/aidankcwu/claude-hackathon
Inspiration
Every professional has been blindsided in a meeting. You present a proposal you've spent weeks on, and someone asks the one question you never considered. The room goes quiet. The project stalls. We've both experienced this and realized the problem isn't bad proposals. It's that people prepare in an echo chamber. You wrote it, you believe in it, and that's exactly why you can't see its weaknesses. The traditional fix is grabbing a colleague for a quick gut check, but that depends on who's available, takes days, and still misses angles. We wanted to build something that gives every professional access to a full boardroom of sharp, opinionated advisors whenever they need it.
What it does
Devil's Advocate is an AI powered advisory board that pressure tests your business proposals before the room does. You upload your proposal document or describe your idea, and the system interviews you with sharp, adaptive follow up questions to understand the full context: who the stakeholders are, what's been tried before, what you're already worried about. Then it deploys five independent AI advisors, each with a distinct expert perspective. The CFO analyzes financial risk and ROI. The Skeptic stress tests your logic and evidence. The Customer Advocate considers how this affects the people impacted. The Operator evaluates whether this can actually be executed on your timeline with your team. The Strategist looks at competitive positioning and whether this decision ages well over two to three years. Each advisor works independently and cannot see the others' analyses. After all five complete, a synthesis engine cross references their outputs to find convergence patterns, revealing which risks multiple advisors independently flagged without influencing each other. That convergence signal is something you fundamentally cannot get from asking a single chatbot for multiple perspectives. The final output includes the three most likely objections you'll face with rehearsable responses, specific changes to make to your proposal before the meeting, and a wildcard blind spot that only one advisor caught. You can also click into any advisor and ask them follow up questions in a live conversation.
How we built it
The backend is Python with FastAPI, using the Anthropic Claude API through the official SDK. The core analysis fires five simultaneous Claude API calls using asyncio.gather, each with a distinct system prompt and structured JSON output requirements. A sixth synthesis call receives all five advisor outputs and performs convergence analysis. We built the entire backend with async patterns so the five advisor calls run truly in parallel rather than sequentially. The backend also includes SSE streaming for real time token delivery, exponential backoff retry logic on all API calls, in memory caching by transcript hash so repeated analyses return instantly, and a demo mode with pre crafted fixtures for zero API call demonstrations. Beyond the core analysis, we built nine additional endpoints including an adversarial mock meeting mode, a pre mortem failure analysis, alternative proposal framings for different audiences, a comprehensive question bank, sensitivity analysis on key assumptions, a risk mitigation playbook, meeting talking points, and a full export system. The frontend is a single HTML file with Tailwind CSS and vanilla JavaScript, served as a static file by FastAPI. The results screen features an immersive war room scene built with CSS perspective transforms and GSAP animations. A wooden conference table with warm overhead lighting creates the atmosphere, and five advisor panels are positioned around it in an arc. GSAP ScrollTrigger drives the transition from the war room to the preparation summary as the user scrolls, with panels flying off screen and the room blurring into the background. Each advisor can be clicked to expand a two column overlay showing their full analysis on the left and a live chat interface on the right.
Challenges we ran into
The biggest challenge was getting Claude to return consistently valid structured JSON across five parallel calls. Each advisor needs to return an exact schema with specific field names, and even one malformed response breaks the entire analysis pipeline. We solved this with strict prompt engineering, explicit JSON schema instructions, and defensive parsing with fallbacks on the backend. Another challenge was the frontend backend integration. We built the two sides completely independently for the first two hours using mock data and a shared contract defining the exact JSON shapes. When we merged, field naming conventions (camelCase on the frontend versus snake_case from Python) caused silent rendering failures where cards appeared blank with no error messages. We also struggled with making the war room scene feel atmospheric without tipping into gimmicky. The CSS perspective table went through several iterations before finding the right balance of dramatic and credible. Getting GSAP ScrollTrigger to work with the sticky positioning and the scroll transition required careful z index management and trigger point calibration.
What we're proud of
We're most proud of the convergence analysis. When four out of five advisors independently flag the same risk without seeing each other's work, that carries real weight. It's a genuinely novel interaction pattern that you cannot replicate by prompting a single AI for multiple opinions. We're also proud that the tool produces immediately actionable output. The objection prep cards with rehearsable responses, the specific changes to make before the meeting, and the wildcard blind spot are things a real professional could screenshot and take into their meeting tomorrow. The war room visual experience turned out better than we expected and creates a memorable demo moment. And the advisor chat feature, where you can push back on an advisor and get a direct response grounded in their previous analysis, makes the whole experience feel interactive rather than static.
What we learned
The most important lesson was that parallel independent AI calls produce fundamentally different outputs than asking for multiple perspectives in a single conversation. When perspectives are generated in the same context window, they anchor on each other. The fourth perspective is shaped by the first three. Running them independently eliminates that contamination and produces genuinely diverse viewpoints. We also learned that the interview phase is critical to output quality. A one paragraph text input produces generic analysis. A structured conversation that extracts stakeholder dynamics, prior failures, and the user's own anticipated objections produces dramatically sharper results because the advisors can focus on what the user hasn't already considered. On the technical side, we learned how valuable it is to define the data contract between frontend and backend before writing a single line of code. Our entire integration went smoothly because both sides coded against the same JSON shapes from the start.
What's next
We want to add PDF upload so users can feed in their actual proposal documents and the system grounds its analysis in the specific details and claims from the document rather than relying solely on the interview. We want to build a stakeholder simulation mode where users can describe the real people in their meeting and the system creates custom advisor personas that mirror those individuals' known priorities and biases. We plan to add a proposal revision loop where users can update their proposal based on the feedback and re run the analysis to see how sentiments shift and which risks were addressed. We also want to build a collaborative mode where multiple team members can run the analysis independently and compare which blind spots each person caught versus missed. Long term, we see Devil's Advocate becoming a standard step in any professional's meeting prep workflow, the same way spell check became a standard step in writing.
Log in or sign up for Devpost to join the conversation.