Inspiration

The 8D method ends with a promise: D7, prevent recurrence. Lean manufacturing has a word for the part of that promise that is easiest to skip, yokoten: once a fix is proven on one line, carry it sideways to every line and part where the same failure can occur.

I do not work in a plant. I picked this problem because it is a pure context problem. The complaint is a ticket, the 8D is a document, and "we fixed this on line 2 last spring" is in someone's memory. When the same defect appears on line 3, nothing connects the new ticket to the old fix.

Jira is where the complaint already arrives. So I built the memory there.

What it does

Yokoten 8D is a Forge app for Jira that turns every 8D into searchable organizational memory, and uses that memory at the moment it matters.

  • Seen before. A new complaint is created in Jira. Within about half a minute Yokoten comments on it: this is a recurrence of ARCHIVE-3. The fix exists, proven on DC-2, but it was never deployed to DC-3. The match is explainable - same failure mode, same part family, same process, shared symptoms - so the engineer can see exactly why the two cases were linked.
  • Start from what you know. One click copies the earlier root-cause chains, corrective actions and team into the new 8D, marked unverified: it was true there, prove it here. For people with Atlassian accounts, Teamwork Graph shows which teams they sit in today.
  • A guided 8D with a coach. Eight steps in the issue panel, customer response clocks, and a rule-based coach that pushes back on the classic weak answers: a root cause that ends on "operator error" is not finished; "retrain the operator" is not a corrective action; an escape root cause is missing.
  • Yokoten that cannot be skipped. Sister lines and parts are learned from the plant's own history - no asset database to maintain. Every target needs a decision: deployed, not applicable with a reason, or a linked Jira task created in one click. The 8D does not close with an undecided target.
  • Quality memory page. Recurrence rate, yokoten coverage, a Pareto of failure modes, and the list that matters most: proven fixes that never reached a sister line - each one the next recurrence waiting to happen. Teamwork Graph scans the space for past work items that look like defects and offers to add them to the memory.
  • A Rovo agent, a skill and an MCP server. The Yokoten 8D Coach agent answers "have we seen this defect before?", "is this 8D ready to close?" and "which fixes were never deployed?" from the same memory, records what the engineer tells it, and drafts the customer-ready 8D report. The same nine actions are declared through rovo:mcp, with a SKILL.md in Agent Skills format, so an admin can open the plant's quality memory to MCP clients.

When an 8D closes, the report is posted on the issue and a 90-day effectiveness date is set; if the defect returns, the earlier case is marked "recurred" automatically.

How I built it

The app runs entirely on Forge with no external egress and no bundled LLM.

  • Custom UI (React) for the jira:issuePanel and the jira:projectPage, using Atlassian design tokens and Forge theming.
  • Forge KVS holds each 8D case plus a compact index entry the matcher scans.
  • Jira REST for issues, comments, linked yokoten tasks and assignable users. A jira:entityProperty mirrors the 8D state onto the issue, so JQL like yokotenStatus = open AND yokotenRecurrence != no works.
  • Teamwork Graph curated queries (atlassianUserInTeams, jiraSpaceWorkItems) through requestTeamworkGraph.
  • Rovo: one rovo:agent, one rovo:skill in Agent Skills format, nine action modules, and a rovo:mcp module exposing the same nine actions.
  • A product trigger on issue creation and a daily scheduledTrigger for customer clocks and effectiveness checks.

The matching and the coach are deliberately deterministic. All the domain logic sits in a pure core with no Forge imports, so the same code runs in Forge functions, in unit tests and in an offline browser demo. The intelligence that needs language - coaching a conversation, drafting, answering questions - is left to Rovo, which calls into that core through actions.

I designed and built the app with AI coding agents (Claude) as my engineering team.

Challenges I ran into

  • Making a match defensible. A similarity score of 0.83 cannot be explained to a customer. I chose facet matching plus weighted symptom overlap over embeddings, and every match lists its reasons.
  • Explaining a recurrence, not just detecting it. The useful sentence is not "similar to ARCHIVE-3" but "the fix was never deployed to DC-3". That required modelling yokoten targets on the old case and distinguishing five outcomes: never deployed, never assessed, wrongly ruled out, deployed but failed, and same line - the fix did not hold.
  • No master data. The app cannot assume a clean register of which line runs which process. Yokoten learns it from past cases and reads failure mode, part and line out of the issue text using the plant's own vocabulary.
  • The graph is not the docs. The first real Teamwork Graph call failed: on a live site a JiraWorkItem has summary, not the title shown in the sample query, and first is capped at 25. I pulled the SDL from the site (/gateway/api/graphql/twg/schema) and now write queries against that.
  • One behaviour, four front doors. Panel, agent, MCP client and triggers all had to give the same answer, which pushed every rule into the shared core.

Accomplishments that I'm proud of

  • The first screen an engineer sees on a returning defect tells them what the cause was, what fixed it, and why it came back.
  • A closure gate with 19 checks, 13 of them blocking.
  • No external data flow: the app makes no outbound network calls and qualifies for Runs on Atlassian. Data leaves only if an admin switches on MCP access.

What I learned

Context is only useful if it shows up before the work starts. The same information in a dashboard someone has to remember to open would have changed nothing; a comment on the new issue and a banner in the panel do.

What's next for Yokoten 8D

  • A Teamwork Graph connector that writes 8D cases into the graph as first-class objects, so Rovo Search finds them everywhere.
  • Per-customer response clocks and report templates (VDA, Ford Global 8D).
  • PFMEA linkage: when a failure mode recurs, flag the PFMEA line whose occurrence rating was too optimistic.
  • A Marketplace listing.

The sample plant in the demo ("Kestrel Castings"), its people, parts and customers are fictional.

Built With

Share this project:

Updates

Submission history