Scrum4Me

Van idee tot geverifieerde pull request.

Scrum4Me is een Scrum-werkplek waar AI-agents bouwen en jij beslist. Een idee wordt bevraagd, gepland, in een sprint gezet, door agents gebouwd en gecontroleerd voordat het in je repository komt.

Demo-login: gebruikersnaam demo · wachtwoord demo1234

Bèta · desktop-first (1024px+) · accounts en data kunnen in deze fase worden gereset.

Product Backlog in Scrum4Me met PBI's, stories en taken naast elkaar

Scrum4Me is gebouwd met Scrum4Me

sprints afgesloten
145
taken afgerond
1.788
agent-jobs voltooid
805
pull requests gemerged
316
productdocs
315

Deze cijfers komen uit de backlog en repository van Scrum4Me zelf. Peildatum: 4 oktober 2026.

Eén pipeline, vijf zichtbare stappen

Elke stap laat iets achter dat je kunt openen en lezen: een idee, een plan, een sprint, een joblog, een pull request.

  1. 1

    Idee

    Schrijf in één alinea op wat je wilt. Het idee krijgt een code en een status en is de eerste traceerbare invoer.

    Ideeënlijst met ideeën in elke fase, van concept tot gepland
  2. 2

    Grill + Plan

    Een agent bevraagt het idee tot de gaten dicht zijn en schrijft daarna een plan. Een tweede model beoordeelt dat plan voordat er iets wordt gebouwd.

    Ideedetail op het tabblad Plan, met het plan dat een agent schreef
  3. 3

    Sprint

    Een goedgekeurd plan wordt één PBI met stories en taken, in een sprint met een doel. Er draait niets totdat jij start.

    Sprintscherm met Product Backlog, Sprint Backlog en de taken van een story
  4. 4

    Agent-run

    Een worker claimt de job, werkt in een geïsoleerde kopie van je repository en meldt elke stap, test en commit terug.

    Jobsscherm met actieve jobs links en afgeronde jobs rechts
  5. 5

    Geverifieerd resultaat

    Het werk komt binnen als pull request, met plan, testresultaten en commits erbij. Insights laat zien wat er is opgeleverd en wat het kostte.

    Insights met sprint health, burndown en agent throughput

Jij houdt de regie

Agents vragen voordat ze handelen. Toestemmingsverzoeken en vragen komen binnen op je iPhone en Apple Watch, zodat een run niet wacht tot je weer achter je bureau zit.

  • Goedkeuren vanaf je pols

    Sta een verzoek toe of weiger het direct vanuit de melding op je Watch of iPhone.

  • Regels in plaats van herhaalde vragen

    Maak van een terugkerende goedkeuring een gedeelde permission-regel, voor één product of voor alles.

  • Vragen wachten op jou

    Heeft een agent een besluit nodig, dan vraagt hij het en gaat hij verder zodra je antwoordt.

iPhone-app met een openstaand goedkeuringsverzoek en de knoppen Toestaan en Weigeren
iPhone-app met één verzoek en ruimte voor een toelichting
iPhone-app met de lijst van agent-taken
Apple Watch-melding met de knoppen Toestaan, Weigeren en Open op iPhone
Apple Watch met een queue-bericht
Hub-pagina met gekoppelde apparaten en gedeelde permission-regels

Binnen jouw standaarden

Agents werken vanuit wat jij hebt vastgelegd, niet vanuit aannames.

Documentatie-overzicht met mappen voor ADR's, architectuur, patronen, plannen en runbooks

Productdocs met revisies

Architectuur, patronen en runbooks staan bij het product. Agents doorzoeken ze voordat ze bouwen, en elke wijziging bewaart de eerdere versies.

Een productdoc in een eerdere versie, met de versielijst ernaast

Definition of Done

Elk product heeft zijn eigen Definition of Done, en werk wordt tegen zijn plan gecontroleerd voordat het als klaar telt.

Productinstellingen met opties voor agent, auto-review en plan-review

Agent-instellingen per product

Bepaal per product of pull requests automatisch worden geopend en gemerged, welke reviews draaien en hoe een sprint zijn werk oplevert.

Rond de sprint

Issuelijst met code, ernst en status

Issues

Problemen per product of systeem, met ernst, onderzoek en oplossing.

Noteslijst met trefwoordfilters

Notes

Snippets en werkcontext die je wilt bewaren, doorzoekbaar op trefwoord.

Insights met agent throughput, velocity en backlog health

Insights

Sprint health, agent throughput, tokengebruik en backlog health.

Hoe het gebouwd is

Planning-app, worker-console, toolserver en runner zijn losse onderdelen rond één Postgres-database. Code blijft in je eigen git-omgeving.

Scrum4Me-platform: Scrum4Me-web, scrum4me-workers, Neon Postgres, scrum4me-mcp, scrum4me-docker, Claude Code, Forgejo en scrum4me-shared.
  • Next.js 16, React 19, TypeScript en Tailwind CSS v4
  • PostgreSQL met Prisma; realtime via LISTEN/NOTIFY en SSE
  • MCP-server en Docker-runner voor Claude Code; SwiftUI voor iPhone en Watch

Documentatie

Naslag voor wie zelf met Scrum4Me werkt. Open wat je nodig hebt.

Quickstart - runner of lokale MCP-dev

De normale route loopt via de headless Docker-runner. Voor lokaal ontwikkelwerk kun je de MCP-server rechtstreeks aan Claude Code koppelen.

Pad A - normale runner

  1. Maak een implementation-token in scrum4me-workers.jp-visser.nl/api-tokens.
  2. Zet token, Claude OAuth-token en git-credentials in de runner-env.
  3. Start scrum4me-docker op NAS, server of laptop.
  4. Controleer de heartbeat in scrum4me-workers.jp-visser.nl/workers.
  5. Klik in Scrum4Me op "Voer uit".

Pad B - lokale MCP-dev

git clone https://git.jp-visser.nl/janpeter/scrum4me-mcp.git
cd scrum4me-mcp && npm install

# Voeg toe aan Claude Code config
# en gebruik de Scrum4Me MCP-tools direct.

Handig voor toolontwikkeling, product-doc retrieval en lokale inspectie. De productie-runner blijft de aanbevolen route voor echte jobuitvoering.

Liever zonder MCP? Gebruik de REST API met een Bearer-token voor scripts, CI-pipelines en gecontroleerde integraties.

Waar beheer je wat?

Product, backlog, sprint of idea aanpassenScrum4Me
Product-docs, grill- en plan-documenten bekijkenScrum4Me
Jobqueue bekijken of job cancellen/restartenscrum4me-workers
Worker online/offline status zienscrum4me-workers
API-token maken of intrekkenscrum4me-workers.jp-visser.nl/api-tokens
Runner starten op NAS/serverscrum4me-docker
MCP tools aanpassenscrum4me-mcp
Schema/status/job-config wijzigenscrum4me-shared eerst, daarna consumer bumps
Scrum in Scrum4Me

Scrum4Me past een lichtgewicht versie van Scrum toe: de essentie zonder ceremony-overhead. Hieronder staat hoe de kernbegrippen zijn vertaald naar de app.

Hiërarchie

Idea
DRAFT - GRILLED - PLAN_READY
↓ materialiseert naar
Product
Een softwareproject of codebase
PBI
Product Backlog Item, een feature of verbetering
Story
Concrete user story binnen een PBI
Taak
Implementatiestap binnen een story

Terminologie

Idea
Een voorstel of richting voordat het een PBI is. Heeft een grill-fase, waarin Claude het kritisch bevraagt, en een plan-fase, waarin Claude YAML schrijft met stories en tasks.
Grill / Plan
Twee asynchrone Claude-jobsoorten op een idea. Grill produceert grill_md. Plan produceert plan_md, een strikt geparseerd YAML-plan met PBI, stories en task-templates.
Product Backlog
Geordende lijst van alle PBIs per product, gesorteerd op prioriteit en positie.
Sprint
Actief tijdblok met een Sprint Goal. Per product is er maximaal één actieve Sprint tegelijk.
Sprint Backlog
De stories die voor deze Sprint zijn geselecteerd. Stories worden vanuit de Product Backlog gesleept.
Sprint Board
Drie-panelen scherm op één view: Product Backlog, Sprint Backlog en taken per geselecteerde story.
Solo Paneel
Persoonlijk Kanban-bord per product. Toont taken van geclaimde stories in To Do, Bezig en Klaar.
Story-claim
Een developer claimt een story uit de Sprint en wordt assignee. Pull-systeem, niet gepusht door een Scrum Master.
Story-status
OPEN -> IN_SPRINT -> DONE. Bepaalt zichtbaarheid in backlogs en Sprint-schermen.
Taakstatus
TO_DO -> IN_PROGRESS -> DONE. Wordt bijgehouden via UI of REST API door Claude Code.
Activiteitenlog
Per story worden implementatieplan, testresultaat en commit vastgelegd via de API of UI.
Sprint afronden
Bij afsluiting wordt per story gekozen: markeer als Done of zet terug naar de Product Backlog.

Rollen

Product Owner
Bepaalt prioriteit van PBIs en beheert de Product Backlog.
Scrum Master
Bewaakt het Scrum-proces en verwijdert obstakels.
Developer
Voert stories en taken uit via UI of Claude Code.

In v1 is één account gelijk aan één gebruiker met alle rollen. Teamgebruik met rolscheiding volgt in v2.

Gebruikershandleiding

Volg deze stappen om van een leeg account naar een volledig ingeplande Sprint te gaan.

1
Account aanmaken
Ga naar Registreren en kies een gebruikersnaam en wachtwoord. Na registratie word je direct doorgestuurd naar het dashboard. Liever passwordless? Paar je telefoon één keer en log voortaan in via QR. Of test eerst met de demo-account.
2
Product aanmaken
Klik op "Nieuw product" op het dashboard. Vul naam, optionele beschrijving, repo-URL en je Definition of Done in. Het product wordt zichtbaar op het dashboard.
3
Een idee vastleggenIdea-route
Open /ideas, klik "Nieuw idee", vul titel + één-alinea beschrijving in. Status: DRAFT.
4
Laat Claude grillenIdea-route
Klik "Grill me". Een lokale agent stelt kritische vragen via het belicoon. Beantwoord ze; Claude schrijft een gestructureerde grill_md. Status: GRILLED.
5
Maak het plan + materialiseerIdea-route
Klik "Make plan". Claude genereert een YAML-plan (PBI + stories + tasks). Klik "Materialiseer" om het atomair om te zetten naar je product-backlog. Status: PLANNED.
6
Product Backlog finetunen
Optioneel: herorden PBIs en stories handmatig via drag-and-drop. Het meeste werk heeft materialise al gedaan; dit is alleen voor bijsturen of toevoegen van werk dat niet uit een idee komt.
7
Sprint starten
Klik op "Sprint starten" op de productpagina en voer een Sprint Goal in. Per product is er maximaal één actieve Sprint tegelijk. Het Sprint-scherm wordt zichtbaar via de navigatie.
8
Sprint Board - stories slepen en taken aanmaken
Open het Sprint-scherm. Drie panelen verschijnen op één view: Product Backlog links, Sprint Backlog in het midden, taken rechts. Sleep stories naar de Sprint Backlog en selecteer een story om taken te zien.
9
Solo Paneel - claim stories en werk persoonlijk
Open Solo via de navigatie. Claim openstaande stories uit de actieve Sprint en werk je taken af in drie statuskolommen. Klik op een taak voor detail en implementatieplan.
10
Uitvoeringsruntime koppelen
Maak een implementation-token aan in scrum4me-workers.jp-visser.nl/api-tokens en zet die in de runner-env. De workers-app beheert jobs, workers, tokens en repo-access; Scrum4Me blijft de planning-UI.
11
Voer uit + Sync-tab volgen
Klik op "Voer uit" bij een story in het Solo Paneel. Er ontstaat een ClaudeJob; scrum4me-docker claimt via MCP, werkt in een worktree en schrijft status/logs terug. Volg voortgang in de Sync-tab en scrum4me-workers.jp-visser.nl/jobs.
12
Sprint afronden
Klik op "Sprint afronden" op het Sprint Board. Voor elke story kies je: markeer als Done of zet terug naar de Product Backlog. Daarna is een nieuwe Sprint aanmaakbaar.
REST API voor gecontroleerde integraties

Alle API-endpoints vereisen een Authorization: Bearer <token> header. Implementation-tokens beheer je in scrum4me-workers.jp-visser.nl/api-tokens.

# Volgende story uit de actieve Sprint ophalen
              curl -H "Authorization: Bearer $TOKEN" \
              https://<your-instance>/api/products/<product-id>/next-story
GET/api/productsLijst van actieve producten
GET/api/products/:id/next-storyHoogst geprioriteerde open story van de actieve Sprint
GET/api/sprints/:id/tasks?limit=10Eerste N taken van de Sprint op volgorde
PATCH/api/stories/:id/tasks/reorderTaakvolgorde aanpassen (body: { task_ids: string[] })
POST/api/stories/:id/logActiviteit vastleggen: implementatieplan, testresultaat of commit
PATCH/api/tasks/:idTaakstatus of implementatieplan bijwerken