Build. Debug. Ship.
With AI.

RISE Mini is a 2-hour competitive workshop where your team uses AI tools to fix real bugs and build real features in a live codebase. Every role contributes — developers, architects, QA, product managers, UX designers, and programme managers.

5 bugs 2 features 55 minutes

Get Started ↓

rise-mini

$ _

Choose Your Stack

Teams pick one tech stack. Both stacks have the same bugs, the same API contract, and the same seed data. Choose what your team knows best — or pick the one you want to learn.

Next.js (TypeScript)

Backend: Next.js 14 API Routes + Prisma ORM + SQLite
Frontend: Co-located React pages (same process)
Prerequisites: Node.js 18+
Setup time: ~2 minutes
Bug count: 5 (3 frontend + 2 backend)
Best for: Teams comfortable with TypeScript/JavaScript

cd stacks/nextjs && npm install && npm run setup && npm run dev

Spring Boot (Java)

Backend: Spring Boot 3.x + Spring Data JPA + SQLite
Frontend: Shared React app (separate process, proxied)
Prerequisites: JDK 17+ and Node.js 18+
Setup time: ~3 minutes
Bug count: 6 (3 shared frontend + 3 Java backend, incl. bonus cache bug)
Best for: Teams comfortable with Java/Spring

cd stacks/spring-boot && ./mvnw spring-boot:run
# In a second terminal:
cd shared/frontend && API_URL=http://localhost:8080 npm run dev

Or let the script decide

./scripts/choose-stack.sh

Interactive setup that installs dependencies, seeds the database, and starts the app.

The Challenges

Challenge 1: Bug Blitz

“RISE Mini has known bugs. Find and fix them using AI tools.”

The app looks fine at first glance — the dashboard loads, the charts render, the lessons list works. But look closer:

A chart with mislabelled axes — the data is right but the labels are wrong
Deflated scores — some users see lower numbers than they should
A filter that forgets — clearing filters doesn’t quite work
An XSS vulnerability — one lesson description is hiding something nasty
A race condition — double-click “Complete” and watch the count go wrong
[Java only] A stale cache — complete a lesson and the list doesn’t update

Scoring: 5 points per bug fixed. +2 bonus points if a facilitator spots you applying a RISE technique.

Challenge 2: Feature Sprint

“Two API endpoints return 501 Not Implemented. Build them.”

The dashboard has placeholder sections for:

GET /api/compare

Team Comparison — show how your scores stack up against team and org averages

GET /api/recommend

Lesson Recommendations — suggest training based on your lowest dimension scores

The API contract tells you exactly what the response shape should be. The seed data has everything you need. Your job: implement the backend, wire up the frontend, and demo it.

Scoring: Points for working implementation, API contract compliance, test coverage, and architecture documentation.

Two Tracks

Not everyone on the team needs to write code. RISE Mini has two tracks that work in parallel:

Building Track

Write code, fix bugs, ship features. For developers and anyone who wants to code with AI.

› Use AI agents to explore the codebase
› Debug with structured prompts (Error + Code + Expected vs. Actual)
› Generate implementations from API specs
› Write tests alongside features

Augmentation Track

Use AI to produce role-specific artifacts. Same challenges, different deliverables.

See role deliverables below ↓

Role	Bug Blitz Deliverable	Feature Sprint Deliverable
QA Engineer	Test plan + edge cases	Acceptance criteria + test scenarios
Architect	Code review + severity assessment	Architecture Decision Record (ADR)
Product Manager	Triage report + customer comms	PRD + user stories
UX Designer	Error state audit + journey mapping	Wireframes + UX spec
Programme Manager	Incident response plan	Sprint plan + risk register

Cross-Role Bonus (+5 pts): When devs use artifacts from the Augmentation Track to guide their build, the whole team earns bonus points. Cross-role collaboration is the meta-game.

Setup Guide

Prerequisites: Docker Desktop — that’s it. No Node.js, no JDK, no dependency installs.

1

Clone the repo

git clone https://git.corp-apps.com/local/scm/aipd/rise-mini.git
cd rise-mini

Alt: git clone git@git.internal.ru.com:kstar/rise-mini.git

2

Start your stack

# Next.js
docker compose --profile nextjs up

# Spring Boot
docker compose --profile spring-boot up

First run builds the image (~2-3 minutes). Subsequent starts take ~10 seconds.

3

Open http://localhost:3099 and start coding

Edit files in your IDE on your machine — changes hot-reload automatically inside the container.

Or use the interactive setup: ./scripts/choose-stack.sh (choose Docker when prompted)

Prerequisites

Everyone

Git (to clone the repo)
An AI tool (see below)
A laptop with a charger

Next.js stack

Node.js 18+
Check: node --version

Spring Boot stack

JDK 17+
Node.js 18+ (for the shared frontend)
Check: java -version

1

Clone the repo

git clone https://git.corp-apps.com/local/scm/aipd/rise-mini.git
cd rise-mini

Alt: git clone git@git.internal.ru.com:kstar/rise-mini.git

2

Choose your stack

./scripts/choose-stack.sh

Or manually:

# Next.js
cd stacks/nextjs
npm install && npm run setup && npm run dev

# Spring Boot (two terminals)
cd stacks/spring-boot && ./mvnw spring-boot:run
# second terminal:
cd shared/frontend && npm install
API_URL=http://localhost:8080 npm run dev

3
Open the dashboard
```
http://localhost:3099
```

For locked-down environments. Pre-built ZIPs include all dependencies — no internet required after download. You still need Node.js 18+ (or JDK 17+ for Spring Boot) installed.

1

Download the ZIP for your platform and stack

Go to the latest release and download the ZIP that matches your OS and stack choice.

2

Unzip and run

# Next.js — just run (deps pre-installed)
cd stacks/nextjs
npm run dev

# Spring Boot — run the fat JAR
cd stacks/spring-boot
java -jar target/rise-mini-1.0.0.jar
# second terminal:
cd shared/frontend
API_URL=http://localhost:8080 npm run dev

No npm install, no Maven download. Everything is included.

3

Open http://localhost:3099

Verify it works

You should see Alice Chen’s assessment dashboard
A radar chart with 6 dimensions
An overall score (it will look lower than expected — that’s Bug #2!)
A lessons page with 20 training modules

Troubleshooting

Problem	Fix
command not found: node	Install Node.js 18+ from nodejs.org
command not found: java	`brew install openjdk@17` (Mac) or download from adoptium.net
command not found: docker	Install Docker Desktop from docker.com
Port 3099 already in use	Kill the process: `lsof -ti :3099 \| xargs kill`
Port 8080 already in use	Kill the process: `lsof -ti :8080 \| xargs kill`
Spring Boot SSL/certificate errors	Corporate network? Use Docker instead, or import CA certs into Java truststore
Blank dashboard, no data	Next.js: re-run `npm run setup`. Spring Boot: delete `rise-mini.db` and restart. Docker: `docker compose --profile <stack> up --build`

AI Tools Guide

RISE Mini works with any AI coding tool. Here’s how to get the most from each:

Claude Code (CLI) Best for: Full agent-mode debugging and feature building

Reads CLAUDE.md automatically for project context.

# Navigate to your stack and start Claude Code
cd stacks/nextjs  # or stacks/spring-boot
claude

# Example prompts:
"Read CLAUDE.md and find all 5 planted bugs"
"Fix the score calculation bug in ScoreController.java"
"Implement the /api/compare endpoint following API-CONTRACT.md"

Power move: Claude Code reads CLAUDE.md files at each level of the repo. The root CLAUDE.md has the bug table. Each stack’s CLAUDE.md has file paths. Give it context and let it explore.

Cursor Best for: IDE-integrated AI with inline edits and multi-file Composer

Open the stack folder (not the root) as your workspace
Use Cmd+K for inline edits on specific functions
Use Composer (Cmd+I) for multi-file feature work
Add API-CONTRACT.md to your context when building features

GitHub Copilot Best for: Inline completions and Chat panel in VS Code

Inline: Start typing a fix and let Copilot complete it
Chat panel: Paste error messages and ask for explanations
@workspace: Ask about the project structure and bug patterns

ChatGPT / Claude (Web) Best for: Non-developers on the Augmentation Track

Paste the challenge brief and your role’s Skill Card
Ask for deliverables in specific formats (PRD, ADR, test plan)
Copy code snippets from the repo for analysis
Great for generating structured documents quickly

IntelliJ IDEA + AI Assistant Best for: Java developers on the Spring Boot stack

Open stacks/spring-boot/ as a Maven project
Use JetBrains AI Assistant for Spring-specific code generation
Run/debug with IntelliJ’s built-in Spring Boot support

Scoring

Points accumulate across the entire session. Every activity earns points.

Activity	Points	Details
Bug Blitz	5 pts/bug	Max 25 pts (Next.js) or 30 pts (Spring Boot)
Feature Sprint	Up to 25 pts	Implementation + tests + docs
RISE Technique Bonus	+2 pts each	Facilitators award when they spot techniques from Skill Cards
Cross-Role Bonus	+5 pts	Devs use artifacts from Augmentation Track
Pub Quiz	3 pts/question	7 questions, team average
Best Artifact	+10 pts	Awarded to standout non-code deliverable
Best AI Moment	+10 pts	Most impressive use of AI during build time

Winning strategies

Strategy A

Go Deep

Pick Bug Blitz or Feature Sprint and nail every detail. Quality and technique bonuses can push you ahead.

Strategy B

Attempt Both

Fast teams can earn points from Bug Blitz AND Feature Sprint. Higher ceiling, but higher risk of spreading too thin.

Strategy C

Cross-Role Excellence

Have your Augmentation Track members produce artifacts fast, feed them to developers, and earn the +5 cross-role bonus. This is the team play.

FAQ

Do I need Docker?

No, but it’s the easiest path. Docker is recommended because it handles all dependencies automatically — just run docker compose --profile nextjs up. If you prefer native install, you’ll need Node.js 18+ (and JDK 17+ for Spring Boot). Either way, SQLite is the database — zero infrastructure.

Docker is slow or images won’t build

The first build downloads dependencies (~2 minutes). Subsequent starts take ~10 seconds. If builds fail behind a corporate proxy, try the Native Install tab in the Setup Guide instead.

How long is the session?

2 hours total. 55 minutes of build time, plus icebreaker, demos, quiz, and prizes.

Can I use both stacks?

No — pick one per team. Both stacks have the same challenges and API contract, so it’s a fair comparison.

What if I’m not a developer?

The Augmentation Track is designed for you. QA engineers, architects, PMs, UX designers, and programme managers all have role-specific Skill Cards with concrete tasks.

What AI tools can I use?

Any AI tool. Claude Code, Cursor, GitHub Copilot, ChatGPT, Gemini, JetBrains AI Assistant — whatever you have access to.

Do I need to prepare anything?

Clone the repo and run ./scripts/choose-stack.sh before the session. Make sure the dashboard loads at localhost:3099. That’s it.

What are Skill Cards?

Printed cards listing 2–3 RISE training lessons relevant to your role and challenge. They give you concrete AI techniques to try during build time. Facilitators award +2 bonus points when they spot you using them.

Is the app real?

It’s a simplified version of the RISE assessment platform — a real app with real bugs, not a toy example. The bugs are representative of issues you’d find in production codebases.

What’s RISE?

RISE (Readiness Index for Software Engineering) is a framework for measuring and improving how engineering teams adopt AI. It covers 6 dimensions: AI Literacy, Workflow/SDLC, Tooling, Governance, Collaboration, and Business Impact.

Build. Debug. Ship.With AI.