-
-
Read: an old form opens the way InfoPath drew it, with every filled record.
-
X-ray: point at a field to see its type, its calculation and its validation rule.
-
Fill: the form's own rules still run, and Rule Trace says why each value changed.
-
Find and total: search the records as you type, then total them by any column.
-
Triage: each form gets a wave and a death certificate, with the evidence for every cause.
-
Built spec first with Kiro CLI: 22 specs, 586 acceptance criteria, 189 tasks.
-
Kiro drove the built app in a real browser through an MCP server and found bugs no test had caught.
-
4,502 passing tests: core, core in a real browser, web, end-to-end and the Kiro hooks.
-
The first screen: drop your InfoPath files, or start from one of seven tasks on a bundled sample.
-
The first screen now: a library. Your forms and their records are kept in this browser.
-
Fill a form in and press Save: the new record joins the library, next to the old ones.
-
Back up: one .zip with every form and record. Drop it on the page to bring the library back.
-
The count today: 4,537 passing tests. An earlier picture shows 4,502, before the library was added.
Inspiration
Microsoft set July 14, 2026 as the end of InfoPath: Forms Services left SharePoint Online and extended support for InfoPath 2013 ended the same day. The forms did not end with it. HR, finance and facilities teams still hold folders of .xsn templates and years of filled .xml records: leave requests, expense reports, purchase requests.
A template is a cabinet file of XML, XSLT and schemas. The only program that could show one is the program that was retired. An auditor who needs a record from 2014, or an admin who has to decide which forms to move first, cannot even open the file. A team that still fills a form in every week has nowhere to do it.
That makes InfoPath a real dead technology with living users, which is what the Resurrection category asks for.
What it does
InfoPath Afterlife is a web page that takes InfoPath's place for the forms a team still needs. It runs fully in the browser, and no file leaves the computer.
The first screen is a library. Forms and records dropped on it are kept by the browser, so they are there on the next visit. Each form is listed with its records and its last change. From that list a person opens a form, starts a new record, saves a filled-in form as a record, removes what is no longer needed, and backs the whole library up as one file that reads back in.
With a form open, a person can do seven things:
- Read an old form and its records as InfoPath showed them, record by record.
- X-ray a field: see the rule, the calculation and the validation behind it.
- Fill the form in again. The rules still run, and Rule Trace says why each value changed. Then save the record into the library, or download the XML.
- Find one record among many as you type, and total them by any column.
- Keep the records without InfoPath: CSV, Excel, or an archive of plain web pages.
- Document what a form does, as a printable dossier for whoever takes it over.
- Triage a whole folder at once. Each form gets a wave and a death certificate: every cause that stops it, with the file and path of the evidence.
Under the library are seven task cards. Each opens its task on a bundled sample, so a judge needs no InfoPath file to try it. A product page beside the app says what it is, who it is for, and what does not work.
How we built it
Spec first, with Kiro CLI. The engine was written from the file format up, with no InfoPath code and no server:
- a reader for the cabinet (MSCF, MSZIP) container,
- a reader for the form's manifest and schemas, into one form model,
- a renderer that runs the form's own XSLT views and sanitises the result,
- a runtime for rules, calculations and validation, with a trace of every change,
- the web viewer, in React, with the engine in a Web Worker.
Kiro wrote the engine, the seven tasks and every bugfix spec: 71 of the 88 commits. The other 17 are the reviewer's: the entrant, working with a second AI coding assistant that is not Kiro. The library and the product page are among those 17. They were written after the Kiro credits ran out. The README lists each commit under "What Kiro did not write".
The numbers, all from the repository:
- 22 specs: 586 acceptance criteria and 189 tasks.
- 4,537 passing tests: core 3,854, core in a real browser 337, web 141, end-to-end 199, Kiro hooks 6. Kiro wrote 4,497 of them. The reviewer's 40 cover the first screen and the library.
- 23 properties checked with fast-check.
- 48 sample forms: 47 written for this project (fictional data, MIT) with 348 filled records, and one public MIT form.
Challenges we ran into
- The format. A cabinet file with its own compression, three manifest namespaces, and views that are XSLT 1.0 programs. The specs pin each claim about the format to a sample file, a count and a date.
- Looking like InfoPath. The paper uses a font with the same metrics as the original and adjusted line heights, so a form lays out as it did.
- Old markup is hostile markup. The renderer's output goes through a sanitiser. A property test attacks it in a real browser, and it found two holes that no example test had.
- Passing tests were not enough. With every suite green, Kiro drove the built app in a real browser through an MCP server and found defects no test had caught: a sentence cut off at a panel's edge, keyboard focus lost after a click, Find "finance" finding nothing because the list held the stored code "FIN".
- A viewer is not a replacement. The first version read files and forgot them when the tab closed. To take InfoPath's place the forms needed somewhere to live, so the app got a library: one store in the browser, and still no network request.
Accomplishments that we're proud of
- 101 defects found by using the app, each one sent back to Kiro as a bugfix spec: 11 bugfix specs, each with the failing test before the fix and the result after.
- An accessibility table against WCAG 2.2 AA, criterion by criterion, with an axe-core audit.
- A page budget that is kept: the page entry is 97.9 of 100 KB and the Worker 157.4 of 160 KB.
- Honest limits. The README says what is still open and which samples were never reopened in InfoPath.
What we learned
- A spec is the cheapest place to be wrong. The requirements phase found mistakes in our own briefs before a line of code existed.
- Bugfix specs change the conversation. "Current, expected, unchanged" in EARS form, a root cause in the design and a red test first gave fixes that did not break their neighbours.
- Steering works best as facts with evidence, not as style advice.
- An agent with a browser sees what a test does not ask.
What's next
Sharing a library between people: today it lives in one browser, with a backup file to move it. Inside Jira, a Forge app that replaces a form with a native Jira Service Management request type. It exists as a separate project, written with another AI coding assistant and not with Kiro, and it reuses this engine as a bundled file. Inside this repository: the two rich-text defects still open (D1, D2), and more public forms as owners allow.
How Kiro was used
Which Kiro. Kiro CLI only, run headless from the terminal with a custom agent. We did not use the IDE, Web, Crew or powers, so we have no comparison to offer. The whole build was 76 prompts and 9 compactions over two days, about 19 hours of agent time, inside the hackathon's credit pool.
Custom agent (.kiro/agents/afterlife.json). One agent, afterlife, holds the whole working agreement in a file the repository tracks:
- an allowed-tools list, and a list of denied shell commands;
- write access denied under
samples/, so the agent can never "fix" a test by changing a sample; - the steering files and the spec skill as resources, loaded every session;
- the hooks and the MCP server.
It mattered because every session started the same way. Nothing depended on what an earlier chat remembered.
Spec-driven development (.kiro/specs/, 22 folders). Eleven specs went requirements first: requirements.md in EARS form, then design.md, then tasks.md, one phase per turn, with a stop for approval after each. A skill, .kiro/skills/spec/SKILL.md, sets the format: every criterion traces to a line of the brief or is marked "Added" with its reason, and every claim about the file format is checked against a sample and written down with the count, the file and the date.
The other eleven are bugfix specs. Each has bugfix.md (current, expected and unchanged behaviour), a design with the root cause, and verification.md with the failing test before the fix and the result after. They hold 101 defect sections.
Compared with prompting freely: the spec is where disagreement happened. Kiro corrected our briefs with evidence from the samples, and we corrected its designs, before either cost any code. Each task named the tests that end it, so "done" was never an opinion.
Steering (.kiro/steering/, 8 files): product, tech, structure, testing, UX principles, InfoPath domain facts, Forge platform limits, and samples and licensing.
The strategy that paid most: steering came before any spec, and Kiro checked it. The first session did nothing but compare our steering drafts with the sample files and the documents in the repository, and correct them. No application code was written until the steering was true. After that, steering held facts with their evidence, not style advice, and the testing file defined the properties by number, so a spec can say "P5" and mean one thing.
Agent hooks (tools/kiro-hooks/, wired in the agent file, 6 tests of their own):
no-secrets(preToolUse, write): Refuses content that holds a token, a key or a private key block.sample-guard(preToolUse, write and shell): Refuses any change undersamples/, by the write tool or by a shell command.format-on-write(postToolUse, write): Checks the written file's formatting and says so in one line.journal-on-stop(stop): Appends one line to.kiro/JOURNAL.md: files changed by area, tasks ticked per spec.
The sample guard matters most: the samples are the fixed reference every test compares with, so the agent must never be able to change one to make a test pass. We know the hook is really wired in, because during its own proof run it blocked the shell command that carried the test line. The journal holds counts only, never prose, so it cannot leak a prompt.
MCP (docs/kiro/mcp.md). One server: Playwright, pinned to a version, headless, with an isolated profile, and allowed to reach only the local preview of the built app. Kiro used it to walk the app as a person would: fill each sample, use the keyboard only, go to 390 px wide and to 200% zoom, switch to dark and forced colours.
It found what the suites could not, because no test had asked the question. Examples, with the suites green on the same code:
- Rule Trace sentences cut off at the side panel's edge. No test measured a width.
- Focus fell to the page body after a view button was clicked. The test pressed the button by keyboard, where focus happened to stay.
- Find "finance" found nothing: the list showed a dropdown's stored code, "FIN". Every test searched for codes.
- The first click after a task opened did nothing. Every test checked the landing state and none clicked after it.
The document gives each session's calls, screenshots and findings, including the calls that were wasted.
Property-based testing (fast-check, 23 properties, P1 to P23). We used properties where a requirement says "never" or "always":
- the cabinet reader never hangs or throws an untyped error on random or mutated bytes (P1);
- sanitised output has no script, no event attribute and no
javascript:address (P5); - inserting rows and removing them gives back the original XML (P3);
- the rule engine stops within 16 passes, cycles included (P7);
- a CSV export parsed again gives back every value (P11);
- no page of an archive can run script or load anything from outside it (P21).
Did it catch what unit tests missed? Yes, in the place that matters most. P5 found two holes in the sanitiser: the render root could be closed early by the HTML parser, and @import survived inside a declaration value. Both were fixed, and their seeds are replayed on every run. A property also embarrassed us once: one of ours was itself wrong, failed about one run in three, and became a defect in a bugfix spec. P1 found nothing in 1,000 runs per generator, and the file says so.
What Kiro did not write. "The reviewer" is the entrant, working with a second AI coding assistant that is not Kiro. That assistant wrote the steering drafts, the spec briefs and the prompts Kiro was given, ran Kiro CLI, and checked Kiro's work on the built app. The seed (steering drafts, spec briefs, the sample set), the agent file and small steering edits are the reviewer's.
After the Kiro credits ran out, the reviewer also wrote these without Kiro:
- a simpler first screen with icon buttons, one repair of that change, and rounder panels and tables;
- the library: the first screen's list of forms and records, the store in the browser, Save in Fill, removing a form or a record, and the backup file;
- the product page, a separate static page beside the app.
The engine, the seven tasks and every bugfix spec are Kiro's. The library is the one place where the reviewer's code adds to what the app does, and not only to how it looks, so it is named here and not only in the README. For it, three of Kiro's end-to-end test files were changed in four places. That is 17 of the 88 commits. The README names every such commit and file. Two of them depart from a spec on purpose, and the README says where: the first screen has one lead sentence where a spec asks for two, and the library is the one thing the app stores, where two specs say it stores nothing.
Built With
- fast-check
- indexeddb
- kiro
- mcp
- playwright
- react
- typescript
- vite
- vitest
- web-workers
- xpath
- xslt