🤖 Context Engineering for a Product Wiki

October 01, 2025

🏗️ Background

In feature-area-aligned-product-documentation-wiki(Designing Product Wiki Documentation Around Feature Areas), a structured documentation model was established for the License Management product—organizing knowledge by feature area and creating a RAG-ready context layer for both human teams and AI agents.

While that work defined how documentation is structured, it did not fully address how documentation is authored, maintained, and evolved in practice, particularly when using agentic workflows in VS Code to both write documentation and consume it as grounding context for coding.

This project focuses on closing that gap.

🎯 Objective

The goal of this project was to introduce a context engineering layer that enables consistent, low-friction authoring of Feature Area documentation while preserving the structural guarantees of the underlying wiki system.

The system instructions serve two directions of the agentic workflow:

• Authoring: AI agents produce structurally correct, consistent documentation because the system instructions constrain their output.
• Consumption: AI coding agents retrieve documentation that is predictably structured, making it reliable grounding context for code generation, requirement analysis, and implementation reasoning.

Specifically, the instructions are intended to:

• Enable effective editing of Azure DevOps wiki content in VS Code
• Enforce documentation structure, formatting, and style conventions
• Reduce cognitive overhead during documentation updates
• Prevent accidental breakage of automated or embedded artifacts
• Provide agent guardrails for LLM-assisted content generation
• Support long-term maintainability of the documentation system

📚 Scope

The instruction text applies to Feature Area documentation within the License Management product wiki and governs:

• Main Feature Area pages
• Technical Reference documentation
• Support documentation
• Testing documentation

It explicitly does not replace the Feature Area information architecture; instead, it operationalizes it.

🛠️ Solution Overview

📄 System Instructions as an Operational Artifact

The system instructions function as a documentation operating manual embedded alongside the wiki content. Rather than relying on tribal knowledge or individual memory, they encode documentation standards directly into both the human authoring workflow and the agentic coding pipeline.

Key characteristics of the solution:

• Lives close to the documentation it governs
• Written for contributors and tooling, not end users
• Explicitly prescriptive rather than advisory
• Designed to be referenced continuously during editing

🚀 Key Capabilities Enabled

1️⃣ Consistent Authoring in VS Code

The instructions allow Feature Area documentation to be edited effectively outside the Azure DevOps web UI by:

• Defining required document types and sections
• Standardizing file naming conventions
• Locking down heading levels and anchor patterns
• Providing repeatable templates for common sections

This ensures that local editing, previewing, and committing changes does not degrade wiki consistency.

2️⃣ Style and Structure Enforcement

The instruction text enforces consistent documentation patterns across Feature Areas, including:

• Fixed four-part documentation model
• Standardized release item formatting
• Defined placement of use cases, requirements, and release entries
• Clear guidance on personas vs archetypes

This eliminates stylistic drift over time and across contributors.

3️⃣ Reduced Cognitive Load During Updates

By encoding decisions such as:

• Where release notes belong
• How detailed setup and verification steps should be
• How headings should be structured for predictable anchors

…the instructions remove the need to re-decide formatting and structure on every update. Contributors can focus on content accuracy and intent rather than mechanics.

4️⃣ Reliable Mermaid Diagram Usage

Mermaid diagrams are supported but deliberately constrained.

The instructions:

• Enforce Azure DevOps–compatible syntax
• Prohibit styling, themes, and visual customization
• Favor concise, conceptual diagrams over detailed flows
• Define node naming and layout preferences

This ensures diagrams render reliably and remain maintainable, especially when authored or updated via VS Code or AI tooling.

5️⃣ Protection of Automated and Embedded Artifacts

The instruction text explicitly identifies elements that must not be modified, including:

• Azure DevOps embedded query IDs
• Automated front matter and file structure
• .order navigation files
• Query-table syntax

This protects the integrity of automation that keeps documentation live and connected to work item tracking.

6️⃣ Context Engineering for Reliable Agentic Workflows

By making structural rules explicit as system instructions, this project is an exercise in context engineering—deliberately curating the rules, constraints, and examples an AI agent receives so it produces reliable, grounded outputs.

The instructions function as agent guardrails that constrain:

• Section placement and heading hierarchy (structured output constraints)
• Diagram syntax (platform-compatible Mermaid only)
• Entity naming (grounded in the canonical data model)
• Archetype references (linked, not duplicated—enforcing single source of truth)

This is the human-in-the-loop (HITL) pattern in practice: AI agents generate, system instructions constrain, contributors validate. The result is documentation that is both AI-authored and AI-consumable—closing the loop between the wiki as context layer and the coding agents that depend on it.

🔗 Relationship to the Original Feature Area Wiki Design

The feature-area-aligned-product-documentation-wiki(Feature Area wiki design) defined what exists and where it lives. This project defines how that system is operated day to day—by both people and AI agents.

Together, they form a complete documentation system where information architecture provides consistency, and context engineering provides execution discipline.

🌟 Outcomes

As implemented, this context engineering approach has resulted in:

• Faster and more consistent documentation updates
• Reduced formatting errors and rework
• Improved durability of diagrams and embedded queries
• Lower onboarding friction for new contributors
• Better alignment between product, engineering, QA, and support documentation
• Reliable grounding context for agentic coding workflows on the product

Most importantly, it ensures that documentation quality is a property of the system, not individual effort.

🔄 Enabling the Agentic Coding Loop

The ultimate value of this context engineering layer extends beyond documentation quality. Because the wiki is structured predictably and authored reliably, it becomes grounding context for agentic coding workflows on the product itself.

When a coding agent needs to implement a feature change, it can:

1. Retrieve the relevant Feature Area documentation (RAG)
2. Ground its understanding in the canonical data model, use cases, and integration points
3. Generate code that aligns with documented requirements and system behavior
4. Update the documentation to reflect the change—constrained by the same system instructions

The context engineering layer ensures that both sides of this loop—documentation-to-code and code-to-documentation—remain structurally sound. This transforms the wiki from a passive reference into an active participant in the development workflow.

📝 Summary

This project formalizes the context engineering required to sustain a scalable, Feature Area–based product wiki. By introducing explicit system instructions alongside the documentation itself, it enables reliable agentic authoring, grounded coding workflows, and consistent collaboration between human contributors and AI agents—while preserving the structural guarantees established by the original wiki design.

Categories: projects

Tags: product-management, systems, technology