Current Consulting · Cyber-Defense Documentation

Using AI to Build a Documentation Set From Scattered, Outdated Sources

With only weeks before delivery, the client needed administrator and end-user documentation. The available inputs included AI output, scattered notes, specifications for an older architecture, SMEs, the product itself, and additional research.

The Problem

With only weeks before the initial delivery deadline, the client needed administrator and end-user guides for the current release of a cyber-defense platform. The guides had to support configuration, data ingestion, operations, investigation, and management tasks for administrators, security analysts, threat hunters, and other operational users.

The available source material was not a coherent body of current documentation. Specifications for earlier releases, scattered notes and reference files, white papers, and individual emails had been loaded into the company's AI system without enough context to distinguish the current product from its older architecture.

I used the AI output as one input, then filled and corrected it through SME interviews, direct questions, hands-on product use, and additional research. The immediate need was to turn those uneven sources into a usable documentation set without quietly presenting an earlier architecture as current behavior.

Why It Was Hard

The older specifications, white papers, files, and emails could not simply be discarded because they contained context that did not exist anywhere else. Their apparent authority also made them risky. A polished explanation could be internally consistent and still describe a capability, relationship, or workflow that the current release no longer used.

The same mixed-generation material had been loaded into the company's AI system without enough context for the system to distinguish one release from another. Its answers could therefore combine accurate details from different points in the product's history. I could verify many individual details, but some of the basic architecture had changed dramatically.

The missing current information had to be gathered and verified through hands-on use of the product, interviews, and direct follow-up questions. Each answer filled part of the gap, but it still had to be compared with observable product behavior and the rest of the available evidence.

The audience added another constraint. Administrators needed configuration and control instructions, while security analysts, threat hunters, and other users needed task-based paths through the same platform. The product itself was still evolving, so I had to distinguish current behavior from inherited explanations while I wrote the documentation. Waiting until a final review to resolve contradictions would have been too late.

What I Figured Out

Current behavior had to be reconstructed from evidence rather than inherited from the newest or most polished source.

Hands-on product use established the behavior I could observe directly. Interviews and follow-up answers clarified the underlying architecture and behavior that the interface did not reveal. I compared those findings with the older material, resolved conflicts, and built a current model of the product before turning the information into guides.

What I Changed

Reconstruct the Current Product

I began by using the product directly, interviewing people who understood different parts of it, and asking specific follow-up questions about behavior the source material did not explain. The interface, available actions, interview answers, and observable system behavior established a working model of the current release and a baseline for evaluating every inherited explanation.

Separate Current Behavior From Product History

The specifications from earlier releases, reference files, white papers, emails, and interview answers filled important gaps, but they could not be treated as current by default. When sources disagreed, or when it was unclear whether something had changed, I used current product behavior and direct questions to determine what to carry forward. A round of review provided another check by surfacing places that still needed clarification or correction and helping confirm which behavior belonged to the current release. This preserved useful product history without allowing obsolete architecture to define the present release.

Build Different Paths Through the Same Product

A single tour of the platform would not serve people doing fundamentally different work. I organized the material into administrator and end-user guides, with task paths tailored to five distinct roles. I then developed the workflows, screenshots, diagrams, and callouts each path required. The material covered system concepts, access controls, data ingestion, configuration, operations, analyst and threat-hunter work, and management workflows without forcing every reader through the same sequence.

Separate AI Output From Product History

The company AI helped surface information from the older material, but it could not reliably identify which architecture was current. I treated its answers as leads rather than as a model of the present product. Where the architecture had changed, I rebuilt the explanation from product use, interviews, and direct follow-up questions.

This engagement was a concrete example of the problem I discuss in Can Your AI Tell Which Documentation Is Authoritative?: retrieval can find relevant material without knowing which version should govern the answer.

What Changed as a Result

Beta administrator and end-user guides were delivered and reviewed within the compressed schedule. Final revisions are complete, and the finished guides will provide the foundation for client training materials. The validated model of the product can now carry forward instead of forcing each new deliverable to reconstruct the system again.

Evidence and Technical Detail

The work combined hands-on product use, interviews, direct questions, specifications from earlier releases, a small set of reference files, white papers, emails, UAT findings, and AI-assisted source work. Role- and task-based information architecture, administrator and end-user workflows, screenshots, diagrams, and callouts turned that scattered material and newly gathered information into usable documentation.

This is current, sanitized work. It reflects the engagement's present status without exposing proprietary screens or product details.