Ismail Khan

Wiki

8 min read

A personal, LLM-maintained knowledge base covering three subjects: LLMs and AI, technical program management, and technical product management. The repo name predates the last two. See CLAUDE.md for how this wiki is structured and maintained, and references/ for the raw sources it’s built from.

Method

How this wiki itself works — the pattern it implements and the format it’s written in.

  • The LLM Wiki Pattern — have an LLM incrementally build and maintain a persistent, interlinked wiki over your sources, instead of re-deriving synthesis from raw documents on every query.
  • Wiki Operations — the three recurring operations over an LLM wiki (ingest, query, lint), plus the roles of index.md and log.md.
  • Open Knowledge Format (OKF) — Google Cloud’s open specification formalizing the LLM-wiki pattern as a portable bundle of markdown files with YAML frontmatter.
  • Operating This Wiki — the operator’s manual for this bundle: layer ownership, the prompts that drive each operation, the frontmatter fields in use, and how a note reaches the published site.

Agentic design patterns

Architectural patterns for agentic AI systems — how to organize components, integrate the model, and orchestrate one or many agents.

  • Agents vs. Workflows — the architectural line between a system whose path is fixed in code and one where the model chooses its own: Anthropic’s definitions, the five workflow patterns, the guidance to build neither, and how the distinction degrades as it circulates.
  • Choosing an Agentic Design Pattern — the decision framework: whether you need an agent at all, the four requirement dimensions, and which pattern fits which workload shape.
  • Single-Agent Pattern — one model, one tool set, one system prompt; the baseline architecture and recommended starting point.
  • ReAct Pattern — thought, action, observation in a loop; the reasoning technique that raises a single agent’s ceiling.
  • Multi-Agent Systems — decomposing one objective across specialized agents, and engineering the context each one sees.
  • Sequential Pattern — a fixed linear chain where each agent’s output is the next agent’s input.
  • Parallel Pattern — concurrent fan-out to independent subagents, then a gather step that consolidates their outputs.
  • Loop Pattern — a sequence of subagents repeats until a termination condition is met.
  • Review and Critique Pattern — a generator produces output and a critic gates it against fixed criteria.
  • Iterative Refinement Pattern — agents progressively improve a result held in session state across cycles.
  • Coordinator Pattern — a central agent decomposes the request and dynamically routes each sub-task to a specialist.
  • Hierarchical Task Decomposition Pattern — the coordinator pattern applied recursively, down through multiple layers to worker agents.
  • Swarm Pattern — all-to-all collaboration and debate with no central orchestrator.
  • Human-in-the-Loop Pattern — the agent pauses at a checkpoint and waits for a person to approve, correct, or supply input.
  • Custom Logic Pattern — orchestration written as code, mixing the other patterns for workflows that fit no template.

Practices

How to actually work with these models — the disciplines, not the architectures.

  • Context Engineering — curating and maintaining the optimal set of tokens an LLM sees during inference; the discipline that supersedes prompt engineering once you move from one-shot prompts to agents running in a loop.
  • Prompt Engineering — structuring natural-language input to get specified outputs; the techniques catalog, why prompts are brittle, and what actually happened to the term.

Agent skills

Packaging procedural knowledge so an agent loads it only when the task calls for it.

  • Agent Skills — folders of procedural knowledge an agent loads on demand; the open SKILL.md format, the progressive disclosure that makes it cheap, and how Claude Code discovers, scopes, and invokes them.
  • Agent Skills Best Practices — how to write a skill an agent actually finds and follows: sourcing it from real expertise, spending context sparingly, calibrating how prescriptive to be, and iterating against evaluations rather than assumptions.

AI-native SDLC

Anthropic’s playbook for rebuilding the software development lifecycle around agentic coding — twelve plays across six stages, each with its own governance story and metric.

  • The AI-Native SDLC — why the bottleneck moved out of the build phase, the six stages as a loop rather than a line, and the committed artifact that carries work between them.
  • Capture as intent.md — the originator brainstorms the idea with Claude and commits it as a version-controlled proto-spec in their own terms.
  • Requirements and Design in One Session — Claude turns an approved intent into a spec constrained by the organization’s skills, flagging the policy conflicts an analyst would have escalated.
  • Plan Mode as the Default Starting Point — the plan becomes reviewable before any code exists; also auto mode and the legacy source-of-truth problem.
  • The CLAUDE.md as Institutional Memory — the onboarding document a new joiner would need, kept under a page and corrected whenever Claude makes the same mistake twice.
  • Skills as Institutional Knowledge — one inconsistently-enforced policy encoded as a skill, understood as an advisory control that needs a deterministic hook behind it.
  • Parallel Sessions and Subagents — one engineer drives several sessions in separate worktrees, with recurring jobs packaged as subagents; the ceiling is review capacity.
  • Give Claude a Feedback Loop — the session verifies its own work before an engineer sees it, and the check is protected from the agent fixing the code.
  • Continuous Evals in CI — real tasks with checks, run whenever CLAUDE.md, skills, or hooks change, because configuration steers the agent and deserves regression testing.
  • AI in the PR Review Loop — every PR gets an identical set of review passes defined in REVIEW.md, and human attention moves up to intent and risk.
  • Hooks as Approval Gates — each human approval expressed as a hook that can allow, ask, or block, with the regulated-enterprise managed settings file annotated key by key.
  • CI/CD Integration and Deployment — Claude runs non-interactively in the pipeline for the judgment steps, sandboxed, with deploy and rollback exposed through MCP.
  • Closing the Loop on Metrics — a deterministic detection script invokes Claude on a control-band breach, and the diagnosis is written back as an intent.md that restarts the lifecycle.

Protocols

Open standards for wiring agents to the things they need — tools, data, and each other.

  • Model Context Protocol (MCP) — an open standard for connecting AI applications to external systems; the USB-C port for AI, and the client-server architecture, two layers, and primitives that implement it.
  • A2A (Agent2Agent) Protocol — an open standard for agent-to-agent communication, letting agents from different vendors and frameworks discover each other and collaborate as peers rather than being wrapped as each other’s tools.

Program and product management

The delivery and product disciplines, taken from their normative standards and the research behind them rather than from the derivative layer that restates them.

  • Brooks’s Law — adding manpower to a late software project makes it later: the five mechanisms behind it, why managers who know the law staff up anyway, the two conditions under which adding people genuinely works, and what to try first.
  • The RACI Matrix — Responsible, Accountable, Consulted, Informed: one instance of the responsibility assignment matrix; how to build one, the column-and-row analysis that is the only reason to keep it, the ITIL and COBIT versions, and the decision-authority gap it structurally cannot fill.
  • The DACI Framework — Driver, Approver, Contributor, Informed: a decision-roles framework whose unit is one question, not one project; the Atlassian play it actually comes from, the uncited statistic on its own vendor page, and the decision register that is the part worth maintaining.
  • DACI vs. RACI — not competing frameworks but different units of analysis; the role mapping and the three places it breaks, the decision-authority cell RACI lacks, how RAPID and DARE fill it, and why most IT projects should run both.
  • The Pareto Chart — sorted bars plus a cumulative line, pointed at an IT defect backlog: choosing the category axis, weighting by cost rather than count, what the empirical software-defect literature says about whether 80/20 holds, and the ways the chart misleads.
  • Dependency Mapping — making the links between work items, teams and systems explicit before they surface as blockers: the two different things IT calls dependency mapping, the taxonomy that tells you which dependencies are removable, the cycles a Gantt chart structurally cannot draw, and the register that is the artifact worth maintaining.

Certifications

Study notes for certification exams — bullet-point summaries of official course material, not general concept pages.

Meta

21 items under this folder.

Graph View