🏎️ Williams Strategy Deck (Sprint VIX)

"The Bloomberg Terminal meets Formula 1 Strategy... for Jira."

💡 Inspiration

We’ve all seen the "Watermelon Project": Green on the outside (status reports look fine), but Red on the inside (hidden risks, scope creep, and burnout).

In Formula 1, race engineers don't rely on "gut feelings" to know when tires will fail. They use telemetry—analyzing tire degradation, lap time variance, and track temperature to predict the exact lap a "crash" in performance will occur.

We asked: Why don't we do this for Software Engineering?

Most Agile tools calculate Velocity (speed). We wanted to calculate Volatility (risk). Inspired by the VIX (Fear Index) in finance and Monte Carlo simulations in F1 strategy, we built a Rovo Agent that predicts if your sprint will crash before it happens.

⚙️ What it does

Williams Strategy Deck is an AI-powered Risk Engine for Jira that replaces the "Scrum Master's hunch" with mathematical probability.

1. The Rovo Race Engineer: You chat with a specialized Rovo Agent using natural language.
   • "How is the sprint looking?"
   • "What is our crash risk?"
2. The Sprint VIX Score: The agent analyzes live Jira data to generate a volatility score (0–100).
   • 0-20: Clean Air (Low Risk)
   • 80+: Red Flag (Crash Imminent)
3. Monte Carlo Simulation: The app runs 1,000 simulated futures of the current sprint. It introduces random variance based on "Ticket Churn" and "Staleness" to calculate the exact probability (%) of missing the sprint goal.
4. Strategic Advice: Just like an F1 strategist calling "Box Box," the agent recommends specific actions (e.g., "Drop ticket JIRA-402 to secure the finish").

🛠️ How we built it

We built this as a cloud-native Atlassian Forge app, adhering to strict "Quant Engineering" principles.

• Platform: Atlassian Forge (FaaS) for secure, zero-config hosting.
• AI Engine: Rovo Agents configured with a specialized system prompt to enforce the "F1 Race Strategist" persona.
• The Math Layer (The Secret Sauce): Written in TypeScript, we implemented a custom Monte Carlo Engine.
  • We map "Ticket Status Changes" to Volatility Factors.
  • We map "Time in Progress" to Tire Degradation curves.
  • The engine runs 1,000 iterations to generate a statistical confidence interval.
• Data Layer: Used @forge/api to fetch live issues, story points, and status history from Jira Software.

🧗 Challenges we ran into

• Quantifying "Chaos": Jira data is qualitative (comments, status moves). Turning that into a hard number for the math engine was difficult. We had to derive a proxy for "Volatility" by weighting ticket churn (back-and-forth movement) heavily.
• Rovo Context: Teaching the Rovo Agent to interpret the raw JSON output from our simulation and translate it into "F1 Metaphors" without sounding robotic took significant prompt engineering.
• Simulation Performance: Running 1,000 simulations in a serverless function has a strict timeout. We had to optimize the math loop to run in milliseconds.

🏆 Accomplishments that we're proud of

• The "Sprint VIX" Algorithm: We successfully brought financial risk modeling into project management. It feels like a real metric, not just a guess.
• Seamless Rovo Integration: The agent feels like a teammate. It doesn't just dump data; it gives opinionated strategic advice ("Box Box now!").
• No UI Required: We embraced the "Chat is the Interface" philosophy. By building a headless math engine, we kept the code clean and the user experience conversational.

🧠 What we learned

• Velocity is a Vanity Metric: Speed doesn't matter if variance is high. Volatility is the true killer of sprints.
• Agentic Workflows: We learned how to wire up Rovo Agents to backend functions, effectively giving the AI "hands" to do complex math that LLMs usually struggle with.
• TypeScript on Forge: The power of strong typing when dealing with financial/statistical models cannot be overstated.

🚀 What's next for Williams Strategy Deck

• Kalman Filters: We plan to upgrade the math engine from Monte Carlo to a Kalman-Bayesian Filter. This would allow the app to "learn" the team's specific volatility patterns over time, adjusting predictions based on historical accuracy.
• Compass Integration: We scaffolded the code to pull component health scores from Atlassian Compass. A "Check Engine Light" for your sprint.
• Real-Time Pit Wall: A live dashboard gadget that plots the Sprint VIX over time, showing the team exactly when the sprint started to destabilize.

Built With

• atlassian-forge
• atlassian-rovo
• jira-rest-api
• monte-carlo-simulation
• node.js
• quantitative-finance
• typescript