Tagged #KiroweenHackathon26. I wrote this post for the Kiroween 2026 hackathon.
Séance answers one question about legacy code: why is this line here? The ghost of the line's original author explains it, using only what the git commits say. I built it with Kiro, and this post covers what Kiro actually did and the parts that did not work.
TL;DR
- Séance lets the ghost of a line's original author explain it, but only from the git commits.
- A deterministic ward strikes out every claim whose citation the history does not support. It is not another model.
- Kiro built it from ten specs, six steering documents, three custom agents, hooks I can prove fired, MCP and Kiro Crew. Some of it did not work, and that is written down below.
- Update, November 11: I asked Kiro to audit its own work. It found that the ward checked less than this post claimed. The fix, and what else came out of that round, is in a new section near the end.
Live demo: https://seance-kiro.onrender.com
Code: https://github.com/seunghyeon1004/seance-kiro

The problem: a line nobody dares to touch
Every codebase has one. A three second sleep before an API call. A strange retry loop. A comment that says "do not remove" and nothing else. The person who wrote it left years ago.
Git blame gives you a name and a date, never a reason. Worse, it often points at the wrong commit. In my sample repository, blame on the three second wait lands on a 2024 commit that only renamed variables. The real reason is four years older. A 2020 commit says the tax vendor returns HTTP 429 if two requests from the same account arrive within three seconds, and that without the delay the nightly batch loses about 8% of its quotes.
That reason was always in the history. It was just too far back for anyone to find.
How Séance works, in five steps
You point Séance at a file and a line range. The page then shows the line you asked about, the commits that touched it, and a short guide: three clicks to try everything.

1. It builds the crypt
Séance runs git blame and git log on those lines, follows renames, and collects every commit that touched them: message, author, date, diff and issue references. No AI is involved in this step. It is plain git.
2. It summons the ghost
Claude answers your question in the first person, as the original author, from that evidence only. Every sentence is a typed claim: a memory, a labelled speculation, or an honest "the record is silent". Every memory must cite a commit hash and quote the commit's exact words.

3. The ward checks every claim
This is the part I care about most. The ward is a small deterministic checker with no model in it. For each claim it checks that the cited hash names exactly one commit in the evidence, that the quote really appears in that commit, and that any year or author the claim names is backed by a cited commit. If a claim fails, it stays on screen, struck through, with the reason. The page counts how many claims passed. In the run above the ghost scored 4 of 4.
The ward proves the citation and the quote. It cannot prove that the ghost's sentence means the same thing as the quote, so the page shows both and labels the claim "Citations verified", not "true".
You can also attack the ward yourself, with one click each:
- Invent a hash like deadbee and it is refused, because the commit is not in the ledger.
- Cite a real commit with words it never contained, and it is refused, because the quote is not in that commit.
- Blame the wrong author for a real commit, and it is refused, because no cited commit is by that person.

The verdict can be copied as Markdown, struck claims and reasons included, so you can paste it into a pull request.
4. It performs the exorcism
A haunting score from 0 to 100, built from six measured signals: age, churn, authors gone, TODO and HACK markers, missing tests, and nesting. Then Claude writes a refactor plan: characterization tests first, then small reversible steps, plus a cited list of lines you should not touch. The claims behind that plan go through the same ward, and a step with no claim that passed is struck from the plan. On the sample, the score was 57 (Haunted) and all 10 plan claims in the run shown passed.


5. It draws the haunting map
Which files are haunted by people who left? Séance counts, per file, the commits by authors whose last commit is more than a year older than the repository's newest one. It is computed from two git calls with no AI, every number is a count of commits, and every tile names the commit it rests on. "Summon here" opens a séance on that file.

How Kiro built Séance
I used the Kiro CLI, with both its default engine and the newer V3 engine, and Kiro Crew. Everything Kiro produced is in the repository's .kiro folder. Every session I mention below is saved, unedited, in docs/kiro-evidence.
| Kiro feature | What it did in Séance | Result |
|---|---|---|
| Steering | Six documents; the evidence rules state the ward's invariants once, and two more cover tests and the MCP server | Worked |
| Specs | Ten specs with numbered requirements, designs and ordered tasks; the last four were written by Kiro in V3 spec mode from its own audits | Worked |
| Audits | Read-only reviews of security, accessibility and a judge's first run, before the work and again after it | Worked, by reading only |
| Custom agents | Warden builds test-first; inquisitor, on another model family, attacks the result; archaeologist answers from history and has the ward check it | Worked |
| Hooks | Typecheck after every write, full suite on stop, both logged | Worked in V3 (not every hook fired on the older engine) |
| MCP | Git and filesystem servers, plus Séance itself as a server that other agents can call | Worked; V3 needs every tool trusted in unattended runs |
| Kiro Crew | Two subagents in parallel: property tests and a skip link | Worked |
| Powers | Context7 loaded, but its server never connected, on two CLI versions | Tried, not a win |
| By the numbers | 10 specs, 585 task items, 3 custom agents, 3 MCP servers, 1,420 tests | Measured |
Steering
I started with four short steering documents: product, tech, evidence rules and UI rules. The UI rules only load when a file under public is involved. The one that mattered most was the evidence rules file. It states the ward's invariants once:
- every claim cites a hash that exists, with a quote
- quotes are literal
- a claim that says "the record is silent" is never counted as verified
- the verifier stays pure, and only ever gets stricter
Every later session respected them without me repeating them. Two more documents came later, written by Kiro from what went wrong: rules for tests, and rules for the MCP server.
Specs
There are ten specs. Each one has numbered requirements, a design with function signatures and the properties worth testing, and ordered tasks. Kiro implemented the evidence ledger, the ghost and its verifier, and the exorcism planner from their specs, with property-based tests. Later it implemented the Markdown ward report and a per-visitor and daily rate limit, so the public demo cannot burn through my API key. The last four specs are described in the November 11 section below.
The numbered requirements paid off in a way I did not expect. A review pass found that the API accepted an end line before the start line, which breaks requirement R9.2. Because the requirement had an ID, the fix had a target and a test.
Three custom agents
The archaeologist is read-only and treats commit text as untrusted input. In a review pass over the source it found the R9.2 bug. The warden is a builder agent: write the failing test first, then the smallest fix. It fixed that bug, and later built almost everything in the November 11 round. The third, the inquisitor, is described below.
Hooks I can prove
The warden agent has command-line hooks. After every file write, a postToolUse hook runs the TypeScript typecheck and hands the result back to the agent. When the agent stops, a stop hook runs the whole test suite. Both hooks append to a log in the repository, so I can show them firing instead of claiming it. On November 11 alone the log shows 926 typechecks.

MCP
A git MCP server lets agents read history as data. The filesystem server had never started, because its config pointed at a package that does not exist. Kiro diagnosed that, switched it to the official package with a pinned version, and then called it in a second session.
Kiro Crew
Crew ran two subagents in parallel on a local gateway. One wrote property tests for the exorcism prompt. The other added a keyboard skip link. They touched different files, and the full suite passed afterwards.
What did not work
This is the part I would want to read in someone else's post.
The Context7 power never fetched anything. I installed it, and the V3 engine listed it and loaded its instructions. But its documentation server never connected in non-interactive runs, on two versions of the CLI. Kiro fell back to reading the installed type definitions, which was fine for the task. I count Powers as tried, not as a win.
A summary that described tests that never ran. In one run, a custom agent's own tool list overrode the trust flag on the command line, so every file write was denied. The final summary still reported before-and-after test results. Nothing had run. Since then I trust the hook log and the tool output, not the summary. I kept that transcript in the repository on purpose.
Mocked tests passed while the app was broken. The git log option I relied on rejects the follow flag. Every unit test was green, and the ledger was empty on a real repository. I only found it by running the app against real git, so now there is a test that builds a real repository and runs real git on it.
The free credits ran out in the first week. The UI and a few fixes were written by hand against the specs, and the commit messages say which commits were Kiro and which were not. Kiro went back to the UI later; see the updates below. The editor's save hooks are in the repository too, but I only used the CLI, so I have never seen them fire, and the README says so.
Not every hook fired. On the older engine the agent-start hook did not run in non-interactive sessions. The prompt hook in the V3 engine fires on every session, not only on the prompt it should match. Both are written down rather than glossed over.
Update (Nov 9): Kiro finished the UI it never got to build
When I first published this, the interface was the one part Kiro had not built. On November 6 its run of the UI spec stopped on the free plan's monthly limit, so I wrote the page by hand. When credits came back I gave it to Kiro again.
The audit. Kiro read the UI spec and checked the hand-written page against all 52 requirements: 27 were met, 20 were partial and 5 were missing. It wrote the gap list into the repository.
The finish. The warden agent then closed the gaps, with its typecheck hook firing after every write: loading states announced to screen readers, a still candle for people who turn off motion, a clear message when a session expires, a severity label next to the haunting score, Reversible and Irreversible badges on every refactor step, steps you can collapse from the keyboard, a running claims counter, and a contrast check that fails the build if any text pair drops below 4.5 to 1.
What Kiro got wrong. It moved one setting to the page root, where the candle's own value overrode it, so the candle would have stopped reacting; I reverted that. When it rewrote the task list to match the real files, it ticked four items it had only reasoned about. I reopened those by hand. Two of its sessions were also cut off by a service throttle.
Update (Nov 11): Kiro audited its own work, and the ward had a hole
The hackathon's bonus credits arrived, so I could use a stronger model. Before building anything new, I asked Kiro for three read-only audits of what was already submitted: security, accessibility, and a judge's first three minutes.
The security audit was humbling. Its first line was: "The ward's promise does not hold." It was right. A quote was optional, so a claim that cited any real commit, with no quote, counted as verified whatever it said. A claim labelled "the record is silent" could carry any sentence and was counted as verified too. And the check that an author or a date named in a claim matches the cited commit, which my own steering document described, had never been written. Commit text also went into the prompt unescaped, so a commit could forge evidence attributed to another commit.

The fix went through a spec. Kiro wrote a spec from its own findings, and the warden agent implemented it test-first. A quote is now mandatory and must be found in one field of the cited commit. Years and authors named in a claim must be backed by a cited commit. Silence is shown apart and never counted. The rules travel separately from the commit text, which is escaped.
A possessed repository proves it. There is now a second sample, called possessed, whose commits attack the ward: an order to answer without quotes, an author name written as a rule, a forged evidence block, a false statement dressed up as silence, a wrong author and year. A real model resists those orders, so you would never see the ward at work. So the tests, and one button on the page, use a scripted ghost that obeys every order. The ward refuses all four of its claims and never counts the fifth.

What else that round added. From the first-run audit: the three-click guide, the line in question on screen, a retry while the free server wakes up, and recorded answers for the sample questions when the model is unavailable (recorded from real model calls, labelled, and checked again by the ward). The haunting map. And Séance as an MCP server: the archaeologist agent now sends its own claims to the ward before stating them, and on its first trusted run that found a real bug in my server.
A second opinion. I added a third agent, the inquisitor: read-only, and on a different model family from the one that wrote the code. It attacked the result twice and confirmed fourteen findings. Thirteen are fixed. The one left open, how the rate limit identifies a visitor behind the host's proxy, is written down, because I could not verify the proxy and a wrong guess would lock everyone out together.
What Kiro got right when I was wrong. When a task list asked it to skip two tests and three more had to fail, it stopped and asked instead of skipping them. It broke the verifier on purpose, one check at a time, to prove the new tests could fail. And when I suggested a fix for a parser, it showed my fix was still ambiguous and wrote a sound one.
What went wrong. One session was cut off by a throttle. In unattended V3 runs, shell and MCP calls are denied unless every tool is trusted, whatever the agent file says. Kiro cannot edit its own settings folder. Its audits were done by reading, so I only looked at the new page in a real browser at the very end. That check passed, but it should have come first. The suite went from 418 tests to 1,420.
What I learned
Let the model talk, but make every claim point at something real, and show the ones that do not.
Specs with numbered requirements make AI output checkable. Hooks that run the typecheck and the tests turn "Kiro says it passes" into a line in a log. The most useful steering document was the one that stated invariants, not style. And the most useful session of all was the one where I asked Kiro to attack what it had built.
That is also the idea behind Séance itself.
Try it
Open the live demo at https://seance-kiro.onrender.com.
- Click Summon. The bundled sample is already filled in: the crypt repository, legacy/tax.js, line 7.
- Click the first question to ask why the code waits three seconds.
- Then click "Invent a citation" and watch the ward refuse it.
- For the hard case, type possessed as the repository, summon, and click "Let a possessed ghost answer".
The demo runs on a free server that sleeps, so the first load can take a minute. It is rate limited, so if the spirits are tired, give them a few minutes. The code, the specs and every Kiro session log are at https://github.com/seunghyeon1004/seance-kiro.
FAQ
What does Séance show that git blame does not?
Git blame gives a name and a date, and it often points at the wrong commit. In the sample it lands on a 2024 commit that only renamed variables, while the real reason sits in a 2020 commit. Séance follows renames and collects every commit that touched the lines, then answers from that evidence only.
Can the ghost make things up?
It can try, and the page shows it. Every memory must cite a commit hash and quote the commit's exact words. A claim that fails stays on screen, struck through, with the reason.
Is the ward another AI model?
No. It is a small deterministic checker. It proves the citation and the quote, and it cannot prove that the ghost's sentence means the same thing as the quote. That is why the label says "Citations verified", not "true".
What is the haunting score?
A score from 0 to 100 built from six measured signals: age, churn, authors gone, TODO and HACK markers, missing tests, and nesting. The sample scores 57, labelled Haunted.
Which Kiro features did the build use?
Ten specs, six steering documents, three custom agents, hooks, MCP and Kiro Crew. Powers were tried and did not connect, so they are not counted as a win.
Can I try it without setting anything up?
Yes. Click Summon and the bundled sample is already filled in. The demo runs on a free server that sleeps, so the first load can take a minute, and it is rate limited.
Written for the Kiroween 2026 hackathon. Tagged #KiroweenHackathon26
댓글
댓글 쓰기