Waarom dit ertoe doet

De vier waarden in het Manifest vertellen een team welke kant het op moet leunen (zie Onderwerp 1.1 — Het Agile Manifest). De twaalf principes zeggen hoe dat opleunen er in het dagelijks werk uitziet: hoe vaak je oplevert, hoe je omgaat met veranderende eisen, wie met wie praat, wat als voortgang telt en hoe een team blijft leren. Ze zijn kort genoeg om uit het hoofd te leren en specifiek genoeg om te toetsen aan wat een team vorige week deed.

Voor een team dat services beheert, zijn de principes nuttig omdat ze dwars door de gebruikelijke scheiding tussen bouwen en beheren lopen. Verschillende ervan, zoals een constant tempo, aandacht voor technische kwaliteit en regelmatige reflectie, beschrijven wat een service jarenlang gezond houdt, en niet alleen wat een functie de deur uit krijgt. Andere principes botsen met gewoonten die rond IT-servicemanagement (ITSM) zijn ontstaan, zoals elke wijziging behandelen als een risico dat moet worden beheerst voordat het gebeurt. De twee naast elkaar lezen toont waar de spanning echt is en waar ze uit oude aannames voortkomt.

De principes zijn in 2001 geschreven over softwareontwikkeling, dus ze noemen geen incidenten, servicelevels of bereikbaarheidsroosters. Die leemte vul je met interpretatie, en die interpretatie is het werk van dit onderwerp. Behandel de onderstaande lezingen als voorstellen om in je eigen context te toetsen, niet als de opvattingen van de auteurs.

Kernconcepten

Waar de principes vandaan komen

De principes zijn gepubliceerd op agilemanifesto.org onder de kop "Principles behind the Agile Manifesto", ingeleid met de woorden "We follow these principles". Ze horen bij het Manifest dat de groep schreef die in februari 2001 in Snowbird, Utah, bijeenkwam. Het Wikipedia-artikel over agile softwareontwikkeling noemt ze de twaalf principes achter het Manifest.

Alleen de vier waarden dragen de handtekeningen van het Manifest. De principes zijn de uitwerking van die waarden door de groep, en ze worden door de meeste teams aangehaald om een praktijk te toetsen. De tekst van elk principe is bij de bron te vinden; dit onderwerp vat elk principe samen in eigen woorden en citeert alleen korte frasen.

De twaalf principes in één oogopslag

De tabel groepeert de principes per thema en geeft van elk een eenvoudige herformulering. De nummers volgen de volgorde op agilemanifesto.org.

# In het kort Wat het kan betekenen voor een team dat services beheert
1 De klant tevredenstellen door vroege en voortdurende oplevering van waarde Lever nuttige verbeteringen aan een service in kleine stappen op in plaats van ze te bewaren voor een grote lancering. Beoordeel succes naar wat gebruikers winnen, niet naar wat het plan zei.
2 Veranderende eisen verwelkomen, zelfs laat Behandel een verandering in wat de klant nodig heeft als informatie, niet als belediging van het plan. Maak je wijzigingsproces snel genoeg om verandering te kunnen verwelkomen.
3 Vaak werkende software opleveren, met voorkeur voor de kortere tijdschaal Houd het interval tussen releases kort, van dagen tot een paar weken. Kleine releases dragen elk minder risico en zijn makkelijker terug te draaien.
4 Zakelijke mensen en ontwikkelaars werken dagelijks samen Zet mensen die de zakelijke behoefte begrijpen elke dag in dezelfde gesprekken als de mensen die de service bouwen en beheren, niet bij kwartaalreviews.
5 Bouw projecten rond gemotiveerde individuen, geef hen steun en vertrouw hen Geef het team de toegang, de tools en de bevoegdheid om problemen op te lossen zonder ketting van toestemmingen. Vertrouwen moet worden aangevuld met duidelijke verantwoordelijkheid.
6 Een gesprek van aangezicht tot aangezicht is de beste manier om informatie over te brengen Praat als een service uitvalt. Leg het resultaat daarna vast. Gebruik video of een gedeeld gesprek als mensen niet op dezelfde plek zijn.
7 Werkende software is de belangrijkste maatstaf voor voortgang Meet wat draait en werkt voor gebruikers, zoals een functie in gebruik of een incident dat niet meer terugkeert, niet geproduceerde documenten of gesloten taken.
8 Duurzame ontwikkeling: onbeperkt een constant tempo Bescherm mensen tegen permanente heldendaden. Een rooster dat afhangt van een paar uitgeputte personen is een risico voor de service.
9 Voortdurende aandacht voor technische uitmuntendheid en goed ontwerp Los de oorzaken van terugkerende storingen op en houd het platform onderhoudbaar. Kwaliteitswerk van vandaag is wat je later snel laat veranderen.
10 Eenvoud: het maximaliseren van het werk dat niet wordt gedaan Verwijder services, stappen, goedkeuringen en documenten die geen doel meer dienen. Alles wat je houdt, moet worden beheerd, bijgewerkt en uitgelegd.
11 De beste ontwerpen ontstaan uit zelfsturende teams Laat de mensen die het dichtst bij het werk staan beslissen hoe ze het doen, binnen duidelijke grenzen. Geef vangrails, geen gedetailleerde instructies.
12 Op regelmatige tijden reflecteren en bijsturen Houd regelmatig reviews van hoe het team werkt, ook na incidenten, en voer uit elk daarvan minstens één echte verandering door.

Vier thema's

De principes vallen in vier groepen die nuttig zijn wanneer je een gesprek plant.

  • Waarde en verandering (1, 2, 3): vroeg en vaak opleveren, en verandering als normaal behandelen. Deze principes staan het meest op gespannen voet met zware wijzigingsbeheersing.
  • Mensen en communicatie (4, 5, 6): dagelijkse samenwerking, vertrouwen en rechtstreeks gesprek. Deze principes tellen het zwaarst tijdens incidenten en overdrachten.
  • Kwaliteit en duurzaamheid (7, 8, 9, 10): werkende uitkomsten als maatstaf voor voortgang, een tempo dat mensen kunnen volhouden, technische kwaliteit en eenvoud. Deze principes beschermen een service over jaren.
  • Leren en zelfsturing (11, 12): teams die beslissen hoe ze werken en verbeteren hoe ze werken. Deze principes sluiten aan op continue verbetering (zie Onderwerp 3.15 — Continue verbetering).

Principes en praktijken zijn niet hetzelfde

Een principe geeft een richting aan. Een praktijk is één manier om het te volgen. Scrum, Kanban en Extreme Programming zijn bundels van praktijken waarvan hun gebruikers zeggen dat ze de principes volgen (zie Onderwerp 1.4 — Leveringsprognoses en planningsmaatstaven, Onderwerp 1.5 — Kanban en Onderwerp 1.6 — Extreme Programming). Een team kan een praktijk volgen en het principe erachter schenden. Een dagelijkse stand-up die een statusrapport aan een manager wordt, behoudt het ritueel en verliest de bedoeling van principe 4 en principe 5.

Waar de principes zwijgen of omstreden zijn

De principes zeggen niets over beveiliging, audit, regelgeving of de kosten van een storing. Ze zeggen niet wie er om drie uur 's nachts bereikbaar is. Een serviceteam moet die kennis uit ITSM en uit de eigen context inbrengen. Critici wijzen er ook op dat principe 6 moeilijk te halen kan zijn wanneer teams over tijdzones verspreid zijn, en dat "werkende software als belangrijkste maatstaf" kan worden gelezen als een negeren van documentatie. Het Wikipedia-artikel over agile softwareontwikkeling vermeldt dergelijke kritiek en merkt op dat het bewijs voor de voordelen van agile methoden beperkt is. Toets de principes aan je eigen resultaten.

Goede praktijken

  1. Gebruik de principes als reviewchecklist. Kies elke maand twee of drie principes en vraag van een recente release, een incident of een project of het gedrag van het team erbij paste. Gebruik echte gebeurtenissen, geen algemene discussie. De waarde zit in de gaten die je vindt.
  2. Verkort het interval tussen releases voordat je automatiseert. Principe 3 geeft de voorkeur aan de kortere tijdschaal. Vraag wat je belet om wekelijks in plaats van maandelijks te releasen, maak een lijst van de blokkades en verwijder ze op volgorde. Automatisering ondersteunt dan een ritme dat je al hebt.
  3. Maak een route voor late wijzigingen. Principe 2 vraagt je verandering te verwelkomen, wat alleen werkt als er een snelle, veilige manier is om haar te accepteren. Definieer een lichte route voor wijzigingen met laag risico en bewaar een uitgebreidere review voor riskante (zie Onderwerp 3.4 — Change enablement).
  4. Zet zakelijke en technische mensen dagelijks in dezelfde ruimte. Principe 4 vraagt om dagelijkse samenwerking. In een serviceteam kan dat een service-eigenaar zijn die aansluit bij de dagelijkse stand-up, of een productvertegenwoordiger die eens per week bij de servicedesk zit.
  5. Stem vertrouwen af op verantwoordelijkheid. Principe 5 vraagt je gemotiveerde mensen te vertrouwen. Zeg duidelijk wat elk team bezit, wat het alleen mag beslissen en wat het moet escaleren. Vertrouwen groeit wanneer beslissingen en hun resultaten zichtbaar zijn.
  6. Eerst praten, daarna vastleggen. Breng tijdens een incident de juiste mensen in één gesprek, ter plaatse of in een gesprek op afstand, en laat iemand beslissingen en tijdstippen noteren terwijl ze gebeuren. Dat dient principe 6 en geeft je een registratie voor latere review (zie Onderwerp 3.2 — Incidentmanagement).
  7. Tel uitkomsten, geen activiteit. Principe 7 maakt werkende software de maatstaf voor voortgang. Kies voor een service maatstaven als tijd tot herstel van de service, hoeveel gebruikers een nieuwe functie gebruiken en hoe vaak een storing terugkeert. Vermijd maatstaven die belonen dat tickets snel worden gesloten zonder iets op te lossen (zie Onderwerp 5.6 — Maatstaven en meten).
  8. Bescherm het tempo. Principe 8 vraagt om een tempo dat het team eeuwig zou kunnen volhouden. Bekijk de bereikbaarheidsbelasting, overuren en het aantal urgente onderbrekingen, en behandel een stijgende trend als een risico voor de service, niet als persoonlijk falen.
  9. Los technische schuld volgens schema af. Principe 9 verbindt kwaliteit met wendbaarheid. Reserveer in elke cyclus een zichtbaar deel voor reparaties, upgrades en tests, en koppel het aan probleemregistraties zodat het werk op bewijs is gebaseerd (zie Onderwerp 3.3 — Probleemmanagement).
  10. Verwijder dingen. Principe 10 waardeert het werk dat niet wordt gedaan. Maak eens per kwartaal een lijst van services, rapporten, formulieren en goedkeuringsstappen en schaf af wat niemand gebruikt of wat het risico niet meer vermindert.
  11. Geef teams vangrails, geen scripts. Principe 11 stelt dat goede ontwerpen uit zelfsturende teams voortkomen. Stel de grenzen vast, zoals beveiligingsregels, budgetten en servicelevels, en laat het team kiezen hoe het daaraan voldoet.
  12. Sluit elke reflectie af met een verandering. Principe 12 vraagt het team te reflecteren en daarna bij te sturen. Spreek na elke retrospective of post-incidentreview één verandering af, benoem een eigenaar en controleer haar bij de volgende review.

Vragen om met je team te bespreken

Welke van de twaalf principes volgen we vandaag het best, en welke het minst?

Geef iedereen de lijst en vraag hen één principe te markeren dat volgens hen goed wordt gevolgd en één dat slecht wordt gevolgd, en vergelijk dan. Onenigheid is nuttig omdat ze laat zien waar mensen het werk verschillend zien. Vraag bij elke markering om een recent voorbeeld. Een facilitator houdt het gesprek bij gebeurtenissen en weg van karakter. Sluit af door één principe te kiezen waaraan het team gaat werken.

Hoe lang duurt het om een kleine, nuttige verbetering bij onze gebruikers te krijgen, en wat vertraagt dat?

Deze vraag toetst principes 1 en 3. Volg één recente kleine wijziging van het verzoek tot de release en schrijf elke wachttijd op. Typische antwoorden zijn goedkeuringsvergaderingen, handmatig testen en releasevensters. Sommige van die wachttijden beschermen tegen echt risico, dus vraag waartegen elk beschermt. Kies daarna één wachttijd om te verkorten.

Wanneer deed een late verandering in wat een klant wilde ons pijn, en wat had het mogelijk gemaakt haar te accepteren?

Vraag om een echt geval en vermijd algemeenheden. Mensen noemen vaak contractvoorwaarden, vaste scope of een release die al was bevroren. Zoek het punt waarop ja zeggen weinig had gekost en vraag wat dat mogelijk had gemaakt. Deze vraag verbindt principe 2 met de manier waarop het team plant.

Wie van de business praat dagelijks met de mensen die onze services beheren en bouwen, en wie zou dat moeten doen?

Breng de betrokkenen bij één service in kaart: de eigenaar, de gebruikers, de ondersteuners, de bouwers. Markeer hoe vaak elk paar met elkaar praat. Gaten ontstaan vaak tussen ondersteuners en bouwers, of tussen gebruikers en iedereen met beslissingsbevoegdheid. Een facilitator kan vragen welk gat de afgelopen zes maanden de meeste problemen heeft veroorzaakt en een klein, regelmatig contact voorstellen om het te dichten.

Wat is er nodig om dit tempo nog vijf jaar vol te houden?

Deze vraag toetst principe 8. Vraag naar de bereikbaarheidsbelasting, weekendwerk en hoe het team denkt over verlof opnemen. Let op antwoorden die heldendaden als normaal behandelen. Vraag naar feiten, zoals hoeveel oproepen buiten kantooruren het laatste rooster opleverde, en houd de discussie bij het systeem, niet bij individuen. Sluit af met één verandering die de belasting verlaagt.

Wat doen we dat we zouden kunnen stoppen zonder een klant te schaden?

Deze vraag past principe 10 toe. Nodig mensen uit rapporten te noemen die niemand leest, vergaderingen die elkaar herhalen en goedkeuringen die nooit iets weigeren. Vraag wie het zou merken als elk ervan werd verwijderd. De antwoorden moeten vóór actie worden gecontroleerd, dus geef iemand de opdracht dat uit te zoeken. Teams vinden hier vaak snelle winst, en de oefening bouwt de gewoonte op om oude regels in vraag te stellen.

In de praktijk: een agile ITIL-voorbeeld

De IT-afdeling van een regionaal ziekenhuis ondersteunt ongeveer veertig klinische en administratieve applicaties met een servicedesk van zes mensen en een klein team ontwikkelaars dat interne tools onderhoudt. Klinisch personeel klaagt dat fixes voor de afsprakenplanner maanden duren, en de ontwikkelaars zeggen dat het grootste deel van die tijd gaat zitten in wachten op de maandelijkse wijzigingsraad en op een rustig weekend om uit te rollen.

Het afdelingshoofd houdt een workshop van een halve dag met de twaalf principes als checklist. De groep kijkt naar de laatste zes wijzigingen aan de afsprakenplanner. Vijf waren kleine fixes, en elk wachtte gemiddeld vijf weken op de wijzigingsraad. De groep ziet dat de principes 2 en 3 in de praktijk niet worden gevolgd, en dat ook principe 4 zwak is omdat de klinisch lead voor de afsprakenplanner wijzigingen pas ziet nadat ze zijn gebouwd.

De afdeling spreekt een proef af. Fixes die slechts één scherm raken, slagende geautomatiseerde tests hebben en binnen minuten kunnen worden teruggedraaid, worden behandeld als standaardwijzigingen en vooraf goedgekeurd, waarbij de klinisch lead automatisch wordt geïnformeerd. Een wekelijkse vergadering van tien minuten tussen de klinisch lead, een ontwikkelaar en een servicedeskanalist kiest wat er als volgende wordt gefixt. Het team voegt een maandelijkse review toe van hoe de wijzigingstypen werken, wat principe 12 dient.

Na drie maanden bereiken kleine fixes de gebruikers in ongeveer een week. De servicedesk meldt minder herhaalde oproepen over bekende bugs. Eén moeilijkheid blijft: twee van de wekelijkse vergaderingen werden overgeslagen toen de klinisch lead op de afdelingen was, en een beslissing die de goedkeuring van de lead nodig had, wachtte een week. De afdeling besluit een vervanger aan te wijzen. Ze ontdekken ook dat sommige medewerkers "vertrouw het team" lazen als toestemming om de notificatiestap over te slaan, dus maken ze de notificatie automatisch in plaats van op mensen te vertrouwen om haar te sturen.

Vier perspectieven

Product- en leveringsteams

Leveringsteams kunnen de principes gebruiken als toets voor hun eigen werk. Vraag of een functie klein genoeg is om snel te releasen, of ze kan worden gemonitord en teruggedraaid en of supportmedewerkers ervan weten. De principes 3, 7 en 9 beslissen het vaakst of een release een geschenk of een last is voor de mensen die haar moeten beheren.

Service- en beheerteams

Beheerteams herkennen verschillende principes als oude waarheden: praat met elkaar tijdens een incident, houd een houdbaar tempo aan en houd het eenvoudig. Gebruik ze om te pleiten voor tijd om terugkerende problemen op te lossen, voor roosters waarmee mensen kunnen leven en voor vroege betrokkenheid bij het ontwerp. Wees bereid uit te leggen welke ITSM-beheersmaatregelen om goede redenen bestaan, zodat het gesprek over het doel gaat en niet over slogans.

Leiderschap en governance

Leiders bepalen hoe ver de principes kunnen worden gevolgd. Verandering verwelkomen betekent accepteren dat plannen verschuiven, en teams vertrouwen betekent accepteren dat je niet elke beslissing goedkeurt. Vraag welk bewijs je nodig hebt om je bij dat vertrouwen op je gemak te voelen, zoals servicelevelrapporten, audit trails of incidentreviews, en zorg dat het team dat zonder zwaar handmatig werk kan leveren.

Klanten en gebruikers

Voor klanten beloven de principes vaak nuttige wijzigingen en inspraak in wat er daarna komt. Ze vragen ook iets terug: dagelijks of minstens regelmatig contact, snelle beslissingen en bereidheid om kleine releases te proberen. Klanten die alleen aan het begin en einde van een project verschijnen, krijgen de langzaamste vorm van de voordelen.

Veelvoorkomende faalpatronen

  • De principes behandelen als een regelboek. Teams twisten over formuleringen en missen de bedoeling. Gebruik in plaats daarvan een principe om een gesprek over een echte gebeurtenis te beginnen en te beslissen wat er moet veranderen.
  • "Verwelkom verandering" lezen als "accepteer alles". Zonder grenzen wordt een service door elk verzoek gedestabiliseerd. Verwelkom in plaats daarvan verandering via een gedefinieerde route die snel risico, kosten en waarde toetst.
  • Vaak releasen zonder kwaliteit. Frequente releases met zwakke tests veroorzaken frequente storingen. Behandel in plaats daarvan principe 9 als voorwaarde voor principe 3 en investeer in tests en rollback voordat je versnelt.
  • Een constant tempo verwarren met een traag tempo. Een team dat "houdbaar" gebruikt om hard werk te vermijden, verliest vertrouwen. Spreek in plaats daarvan af hoe een gestaag, ambitieus tempo eruitziet en meet het over maanden.
  • Gesprekken van aangezicht tot aangezicht vervangen door een tool. Chatkanalen en tickets vullen zich met details die niemand leest. Voer in plaats daarvan een gesprek wanneer iets urgent of onduidelijk is en leg beslissingen daarna vast.
  • Voortgang meten aan activiteit. Het tellen van gesloten tickets of opgeleverde releases beloont beweging. Volg in plaats daarvan uitkomsten die gebruikers kunnen zien, zoals herstelde service, in gebruik genomen functies en minder terugkerende incidenten.
  • Retrospectives houden die niets veranderen. Het team praat en de volgende cyclus is hetzelfde. Spreek in plaats daarvan bij elke retrospective één verandering af en controleer haar bij de eerstvolgende.
  • Het zwijgen van de principes over risico negeren. Teams slaan beveiliging en compliance over omdat de principes ze niet noemen. Voeg ze in plaats daarvan toe als expliciete randvoorwaarden en bespreek hoe je er in kleine stappen aan voldoet.

Volwassenheidsmodel

Dimensie Initiëren Ontwikkelen Standaardiseren Beheersen Orkestreren
Leverritme (principes 1–3) Releases zijn zeldzaam en groot Sommige teams releasen in kleine stappen Teams delen een kort releaseritme en een route voor late wijzigingen Releaseinterval en doorlooptijd worden gevolgd en gereviewd Releaseritmes worden gecoördineerd over services en leveranciers
Samenwerking (principes 4–6) Zakelijke en technische medewerkers ontmoeten elkaar bij mijlpalen Sommige teams overleggen dagelijks met vertegenwoordigers van de business Elke service heeft een benoemde eigenaar en regelmatig contact met zijn gebruikers Gaten in samenwerking worden in reviews gevonden en gerepareerd Klanten en leveranciers nemen deel aan planning en incidentreviews
Duurzaamheid en kwaliteit (principes 7–10) Druk wordt met overwerk opgevangen; kwaliteitsproblemen worden getolereerd Sommige teams volgen bereikbaarheidsbelasting en technische schuld Tijd voor reparaties en een eerlijk rooster zijn in de planning ingebouwd Uitkomsten, belasting en terugkerende storingen worden gemeten en erop wordt gehandeld Vereenvoudiging is routine in de hele organisatie
Leren en zelfsturing (principes 11–12) Reviews vinden alleen na ernstige storingen plaats Sommige teams houden regelmatig retrospectives Elk team reviewt zijn werk in een vast ritme en legt één verandering vast Reviewacties worden tot voltooiing gevolgd en resultaten worden gecontroleerd Verbeteringen van het ene team verspreiden zich zonder centrale sturing naar andere

Checklist

  • Elk teamlid heeft de twaalf principes op agilemanifesto.org gelezen.
  • We hebben één recente release of één incident getoetst aan minstens drie principes.
  • We kennen ons releaseinterval en hebben op een rij gezet wat het verkorten ervan belet.
  • Wijzigingen met laag risico hebben een snelle goedkeuringsroute en riskante wijzigingen een uitgebreidere.
  • Elke service heeft een benoemde eigenaar die regelmatig met zijn gebruikers praat.
  • Incidenten brengen de juiste mensen in één gesprek samen, waarbij beslissingen worden vastgelegd.
  • We volgen de bereikbaarheidsbelasting en bekijken haar minstens eens per kwartaal.
  • Een zichtbaar deel van elke cyclus gaat naar reparaties en technische schuld.
  • We hebben het afgelopen kwartaal minstens één rapport, stap of service afgeschaft.
  • Elke retrospective eindigt met één afgesproken verandering, een eigenaar en een datum om haar te controleren.

AI-prompts

Doel: een recente release of een incident toetsen aan de twaalf principes.

You are helping a team review a recent event against the twelve principles behind the Agile Manifesto.

The twelve principles, in short: (1) satisfy the customer through early and continuous delivery; (2) welcome changing requirements; (3) deliver frequently, preferring shorter timescales; (4) business people and developers work together daily; (5) build around motivated individuals and trust them; (6) face-to-face conversation; (7) working software is the primary measure of progress; (8) a sustainable, constant pace; (9) attention to technical excellence and good design; (10) simplicity, maximizing the work not done; (11) self-organizing teams; (12) regular reflection and adjustment.

Event: [paste a factual, blameless description of a release, incident, or delayed change, in the order things happened].

Pick the three principles most relevant to this event. For each, say in two or three sentences whether the team's behavior matched the principle, citing only details from the event text. Then suggest two questions for the team to discuss. Ask me up to three clarifying questions first if the event description is too thin. Mark assumptions, and list what you are unsure of.

Doel: uitzoeken wat kleine wijzigingen vertraagt, met principes 2 en 3.

I want to understand why small changes take a long time to reach our users. Here is the sequence of steps for one recent small change, with how long each step took: [paste the steps and durations; for example "request raised, 1 day; waiting for change board, 9 days"].

Our change process is described as: [paste a short description of the change approval process, including who approves what].

List the waits in order of length. For each wait, suggest what risk it may be protecting against and one lighter way to manage that risk. Do not claim that any standard or regulation requires a step unless I have pasted its text. Mark where you are guessing, and list what you are unsure of.

Doel: principes omzetten in vragen voor een retrospective.

Create a 45-minute retrospective plan for a team of [number and type of people, e.g. "seven people who build and run an internal payroll service"]. The retrospective should use the twelve Agile Manifesto principles to look at the last [period, e.g. "four weeks"].

Context: [paste 3-5 sentences about what happened in the period, including any incident, release, or conflict].

Include a timed agenda, one activity that surfaces facts, one that groups them by principle, and a closing step where the team agrees exactly one change with an owner and a date to review. Keep it free of any specific tool. If information is missing, ask me clarifying questions first, and list what you are unsure of.

Doel: een voorgesteld proces toetsen op eenvoud (principe 10).

Here is a process we use: [paste the steps, who does them, and the forms or approvals involved].

For each step, ask what purpose it serves, who benefits, and what would happen if it were removed. Then propose a shorter version that keeps the purposes that matter. Flag any step that exists because of an external requirement I have named: [list any laws, contracts, or standards you are certain apply, or write "none known"]. Do not invent requirements. List your assumptions and what you are unsure of.

AI-vaardigheden

  • agile-principles: gebruik dit om een teampraktijk of beslissing aan de principes te toetsen en door te praten over wat elk ervan in context betekent.
  • agile-reflection: gebruik dit om de regelmatige reflectie te houden die principe 12 vraagt en er een echte verandering van te maken.
  • kaizen: gebruik dit om kleine, voortdurende verbeteringen te plannen na een reflectie of review.
  • agile-delivery: gebruik dit om frequente, kleine releases te plannen in lijn met de principes 1 en 3.
  • agile-coaching: gebruik dit om een team te helpen van het volgen van rituelen naar het begrijpen van de principes erachter.

Belangrijkste bronnen

  • Principles behind the Agile Manifesto (agilemanifesto.org): de primaire tekst van de twaalf principes; lees hem helemaal.
  • Manifesto for Agile Software Development (agilemanifesto.org): de vier waarden die de principes uitwerken.
  • History: The Agile Manifesto (agilemanifesto.org): het verslag van de auteurs over hoe de groep bijeenkwam en wat ze wilde veranderen.
  • Agile software development (Wikipedia): een overzicht met geschiedenis, praktijken en kritiek, nuttig om verder leesmateriaal te vinden.

Referenties

  1. Principles behind the Agile Manifesto — Beck et al., agilemanifesto.org — https://agilemanifesto.org/principles.html
  2. Manifesto for Agile Software Development — Beck et al., agilemanifesto.org — https://agilemanifesto.org/
  3. History: The Agile Manifesto — Jim Highsmith for the Agile Alliance, agilemanifesto.org — https://agilemanifesto.org/history.html
  4. Agile software development — Wikipedia — https://en.wikipedia.org/wiki/Agile_software_development
  5. Manifesto for Agile Software Development — Wikipedia — https://en.wikipedia.org/wiki/Manifesto_for_Agile_Software_Development
  6. Continuous delivery — Wikipedia — https://en.wikipedia.org/wiki/Continuous_delivery
  7. Technical debt — Wikipedia — https://en.wikipedia.org/wiki/Technical_debt
  8. Self-organization — Wikipedia — https://en.wikipedia.org/wiki/Self-organization
  9. Kaizen — Wikipedia — https://en.wikipedia.org/wiki/Kaizen