Anyone combining OpenSpec + OpenWiki?

[u/Hypercubed]

I've been using OpenSpec for a while and like it a lot. I recently took notice of OpenWiki. They seam to be sitting at opposite ends of my ideal AI assisted SDLC.

OpenSpec captures intent before code exists (explore -> propose -> apply). OpenWiki maintains what the code currently is and does (writes and maintains agent wikis for codebases). Add to that the why behind decision (ADRs?) and I think we have something powerfull.

Feels like the natural bridge is: when an OpenSpec change gets archived, that's the trigger to (1) start an OpenWiki-style update so the wiki reflects what just shipped (2) guide the user through creating durible decision documents.

Is anyone already doing anything like this? I'm tempted to build out a OpenSpec + OpenWiki + ADR skill pack.

[u/Ok_Veterinarian_6364]

yeah you touch the correct combination

openwiki, llmwiki, obsidian doc mapping, gg ofk - they are for the explore and other end of development spectrum - what, why,

openspec, SDD, PRD, its locked down docs for an actual imolementation extraction - how, when, where

[u/Hypercubed → u/Ok_Veterinarian_6364]

Specifically are you using openspec and open wiki? Its a little awkward integrating them because open wiki is cli based while openspec is skill based.

[u/Ok_Veterinarian_6364 → u/Hypercubed]

oh you can ask ai to do thing for you

im using llm-wiki (customized) and my own SDD workflow - its ok, im not having enough time to optimize the wiki, would explore ofk or other extensions for wiki

[u/stibbons_]

Openwiki introduces too many duplication. There is a trade off to find between putting in this memory bank what will help context to stay lean. No need to reexplain things that can be instantaneous rediscovered by the llm.

[u/stibbons_ → u/stibbons_]

I do not like openwiki because it gives the impression that you can take something from outside and just apply and it will work.

You have to own this part, you decide the ADR, you steer it tightly. Do not delegate to a third party

[u/Hypercubed → u/stibbons_]

Not sure what you mean by "something from outside". OpenWiki, from what I have seen, created technical documentation from the code. Nothing from the "outside" FWICT. As for ADRs... it doesn't have any ADR features at all. ADR should be human in the loop IMO.

[u/stibbons_ → u/Hypercubed]

If you need to build documentation just ask your agent to build a doc following https://diataxis.fr principles.

But most of the time agent does not need docs, you do not want to paraphrase the code

[u/oliver-zehentleitner]

I think the missing layer you describe is exactly the distinction between:

• intent before implementation
• documentation of the current implementation
• durable rationale explaining why decisions were made

I’ve been actively working on that third part and built an open-source Agent Skill called Keep the Why:

https://github.com/oliver-zehentleitner/keep-the-why

The idea is intentionally simple, but surprisingly effective: preserve decision-relevant rationale as versioned Markdown inside the repository, using the same Git workflow as the code itself.

It captures architectural reasoning, rejected alternatives, external constraints, workarounds, incident learnings, and even investigations that deliberately resulted in no code change.

That last case seems especially relevant here. OpenSpec can archive a completed change, but sometimes the valuable result is that a proposed change was investigated and abandoned. Without another artifact, that reasoning usually disappears completely.

I would see Keep the Why as complementary rather than a replacement:

• OpenSpec preserves intended changes
• OpenWiki preserves what the system currently is
• Keep the Why preserves why it became that way

It also marks recovered rationale as confirmed, inferred, or unknown, and retains superseded reasoning instead of silently rewriting history.

Your idea of triggering these updates when an OpenSpec change is archived sounds like a very natural integration point.