The Leanpub 60 Day 100% Happiness Guarantee
Within 60 days of purchase you can get a 100% refund on any Leanpub purchase, in two clicks.
See full terms...
Engineering in AI Era : from specs to loops that remember
The Clarity Series — Teaser
You typed "add multi-tenancy to the billing service" into your coding agent on Friday. Three worktrees, three sub-agents, a reducer at the end.
Monday: forty-three files touched, a green suite, a summary that reads well.
Then someone asks the only question that matters — why is the retry budget three? Who decided that, and against what constraint?
Nobody knows. Not you; you were asleep. Not the agent; its context window closed Friday night and took the reasoning with it. Not the commit log; it records that MAX_RETRIES = 3 was written, not that an agent tried five, watched the rate limiter trip, and settled on three.
The code survived. The intent evaporated.
This is the pattern nobody's tool tutorial covers: AI makes the easy parts of engineering dramatically easier and leaves the hard parts — judgment, rationale, memory — exactly where they were, plus a few new ones.
The Clarity Series is three short, field-tested books that close that gap in order:
📖 The Clarity Engineer — names it. You are a clarity trader, not a code writer. World models, intent documentation, graph explainers, agent identity: the mindset and skills that outlast any model release.
🔨 The Clarity Forge — builds it. Six stages, six copy-paste prompts, one iron rule: the spec is the durable artifact, the code is the side effect. A hybrid Architect/Contractor pipeline — frontier model plans, local open-weight model executes — so clarity stops costing you frontier-model money on every keystroke.
🕸 The Loop That Remembers — gives it memory. The memory isn't the sixth piece of the loop, it's the thing the loop exists to produce. A lat.md/ lattice turned into a queryable metagraph that many agents read and write at once, with an evaluator that cites edges instead of finding prose plausible.
Three books. One test that runs through all of them:
Every important output can be traced to an objective, a plan, an artifact, a source, a graph path, an evaluator decision, and a bounded execution record.
When it's true, agents add throughput. When it's false, agents add opacity.
Stop vibe-coding. Start clarity-trading — and this time, remember why.
Bundled below the price of buying all three separately.
Bought separately
$109
Minimum price
$77.00
$90.00
You pay
Author earns
The following 3 books are included in this bundle...
These books have a total suggested price of $109. Get them now for only $77.00!
About
About the Bundle
The Clarity Series
The Discipline. The Pipeline. The Memory.Three books, one argument, followed all the way down.
AI didn't make software engineering easier. It made the easy parts easier — and left every hard part exactly where it was, plus a few new ones: agents that forget why a decision was made, pipelines that burn frontier-model budget on work a local model could do, loops that ship forty green commits and can't say why the retry budget is three.
The Clarity Series is the field guide for the part nobody's tool tutorial covers. It names the discipline, gives it a pipeline, and then gives that pipeline a memory. Read in order, the three books are one continuous argument. Read separately, each stands on its own and solves a specific, immediate problem.
📖 Book 1 — The Clarity Engineer: Code Is the Side Effect
The discipline.
Software engineers were never primarily code writers — we are clarity traders, translating the ambiguity of business intent into the precision machines demand. This book is the mindset and the skill set for doing that translation on purpose instead of by accident.
You get the four-layer world-model framework agents need to work from (architecture constraints, component contracts, behavior specs, code patterns), intent documentation as the antidote to "the code works but nobody knows why," graph explainers that turn a codebase or a document set into something an agent can actually navigate instead of grep, and a full architecture chapter on what makes an agent coherently itself — identity, the scaling wall that breaks file-based memory, and constraint-based coordination for multi-agent teams. It closes with a production-tested tour of Claude Code and the plugin ecosystem, and a clear-eyed look at what an AI-native organization is once you strip the marketing off it.
This is the book that says what "graduates" of the AI transition actually need to know — not tool tricks, but the mental model and the skills that outlast any specific model release.
🔨 Book 2 — The Clarity Forge: Local AI, Done Right
The pipeline.
Six stages, six copy-paste prompts, one iron rule: the spec is the durable artifact, the code is the side effect. The Clarity Forge is the working version of Book 1's discipline — a hybrid Architect / Contractor pipeline that pairs a frontier model (Opus, GPT-5, Sonnet) for planning with a local open-weight model (Gemma, Qwen) for execution, so you get frontier-grade reasoning without frontier-grade token bills on every keystroke.
You get the full OpenSpec × Grill pipeline (Bootstrap → Grill-Me → Grill-With-Docs → ADR Grill → Tailored Emission → Dispatch → Verify-or-Escalate), the two highest-leverage schemas worked end to end, a real worked example (passkey login, full ADR included), an anti-pattern catalog for the shortcuts that quietly gut the pipeline, and a printable one-page reference card. This is the crew of local, hybrid agents that work your dialect and keep the frontier-model bill honest — the pipeline that turns clarity into money you don't burn.
🕸 Book 3 — The Loop That Remembers: Graph Engineering for Multi-Agent Development
The memory.
Everyone is building loops — generate, critique, revise, sub-agents, worktrees, skills. Every write-up ends with the same shrug: and you'll want some kind of memory. This book takes that shrug seriously: the memory isn't the sixth piece of the loop, it's the thing the loop exists to produce.
It picks up exactly where The Clarity Forge leaves off — the lat.md/ lattice of ADRs and patterns — and turns it into a queryable, typed, provenance-bearing metagraph that many agents can read from and write to at once. You get the two-graph distinction (work graph vs. knowledge graph) and the two predicates that bridge them, a complete twelve-node schema with five checkable invariants, a seven-step bounded context builder, a grounded evaluator that cites edges instead of finding prose plausible, swarm coordination via promise theory, and a full chapter on when not to build any of this. This is the book for loops that remember what they decided and why — and for autonomous coding that survives past Friday night.
Why the bundle
Read alone, each book solves one problem: how to think, how to build the pipeline, how to give it memory. Read together, they are the only sequence that closes the loop — discipline that produces a pipeline, a pipeline that produces artifacts worth remembering, and a memory system that makes the next loop smarter than the last one. The bundle is priced below buying the three separately, and every book stays yours to re-download as it updates.
Who it's for
- Engineers running Claude Code, Cursor, Codex, or any coding agent on real production codebases, who've felt the gap between "the demo" and "the codebase three months later."
- Tech leads who need to explain to stakeholders why an agent decided what it decided — and increasingly can't.
- Teams weighing local open-weight models against frontier-only spend, without giving up planning quality.
- Anyone whose
lat.md/orNOTES.mdhas outgrown grep and more than one writer.
About the Author
Volodymyr Pavlyshyn writes and builds at the intersection of agent orchestration, knowledge representation, and the durable artifacts that make software teams legible to themselves. He is the author of LadybugDB and the Clarity series, and maintains the OpenSpec schema family the second and third books document.
Books
About the Books
Clarity Engineer : Code Is the Side Effect
Building AI-Driven Systems Where Engineering Judgment Is the Real Work
Something strange happened in the years between 2023 and 2026.
Every week, a new headline announced that software engineers were obsolete. Every week, the same software engineers downloaded the latest AI coding tool, integrated it into their workflows, and went back to doing the hard work of understanding complex systems, managing ambiguous requirements, and making thousands of tiny judgment calls that no model had yet learned to make reliably.
This book is about that gap — and how to close it.
Ways of Working is a field guide for engineers who are serious about their craft and want to navigate the AI transition without losing themselves in it. It does not give you prompt templates or tool tutorials. Those become obsolete in months. Instead, it offers frameworks and practices that remain relevant regardless of which specific models and tools dominate the next cycle.
What You Will LearnWhy clarity — not code — is your core product. Software engineers are not primarily code writers. We are clarity traders: we translate the ambiguity of business requirements into the precision that machines demand. AI handles the translation step faster than ever — but only if you first achieve the clarity that makes translation possible.
How to build world models that agents can actually use. The single most common failure mode in agentic development is not hallucination — it is missing context. This book teaches a four-layer framework for giving agents what they need: architecture constraints, component contracts, behavior specifications, and code patterns. Including deep dives into GitHub's Spec-Kit for machine-readable specifications, and graph-based knowledge systems (Graphify, Understand-Anything) that make complex domains navigable.
What agent architecture actually requires. Agent identity, the scaling wall that breaks file-based memory in production, constraint-based coordination borrowed from holocracy, and the emerging Networked Agentic Organization model for human-AI teams.
How to use Claude Code and the plugin ecosystem effectively. A complete guide to Claude Code's CLAUDE.md convention, permission model, slash commands, and hooks — plus the oh-my-claudecode ecosystem with its 15+ specialized agents, workflow orchestration patterns, and skills framework. Focused on patterns that work in production, not demos.
What AI-native organizations actually look like. Beneath the marketing, genuine AI-native organizations have specific characteristics: data quality obsession, research as daily practice, hiring profiles that differ from traditional software engineering, and cultural patterns that compound in capability over time.
Who This Book Is For- Senior engineers trying to understand what "agentic development" actually means in practice
- Engineering managers building teams that will work alongside AI coding agents every day
- Technical leaders trying to distinguish genuine AI-native practices from expensive hype
- Individual practitioners who have noticed that the more they rely on AI, the less certain they feel about what they actually know — and want to understand why
This book assumes you are already a competent engineer. It does not explain what a function is. It does explain what changes when an AI agent writes the functions for you.
What Makes This Book DifferentThe ideas in this book come from building real systems with AI agents — not demos, but production systems that had to work reliably, maintain themselves over time, and evolve as requirements changed.
This experience produces a specific kind of skepticism: skeptical of the "AI will do everything" narrative (because AI-generated codebases regularly collapse under accumulated misunderstanding), and equally skeptical of the "nothing fundamentally changed" narrative (because the engineers who treat AI tools as just faster autocomplete are making a costly category error).
Something genuinely new is happening. The question is whether you can think about it clearly enough to benefit from it.
That is what this book is for.
About the AuthorVolodymyr Pavlyshyn is a software architect and researcher with deep expertise in agentic AI systems, graph databases, self-sovereign identity, and knowledge representation.
He is the author of LadybugDB (Leanpub), a practical guide to graph database and vector search architectures for agent memory systems. He writes regularly about agent identity, world models, networked agentic organizations, and the organizational implications of AI-driven engineering.
His background in hardware engineering gives him an unusual perspective: the principle that the problem defines the algorithm, not vice versa — and the habit of building new tools when existing ones don't fit the problem.
Table of ContentsPart I: The Great Mindset Shift
- Beyond Vibe Coding — You Are a Clarity Trader
- The Paradox of Intensification
- Cognitive Sovereignty — Renting vs. Owning Your Intelligence
Part II: World Models and the Architecture of Intent 4. World Models for Agentic Coding — The Four-Layer Framework 5. Intent Documentation — Why Agents Need Your Why 6. Spec-Kit — Formal Specifications for the Agent Era 7. Graph Explainers — Making Knowledge Machine-Readable
Part III: Agent Architecture 8. Agent Identity — Beyond Names and Roles 9. The Scaling Wall — From Files to Databases in Multi-Agent Systems 10. Holocracy as Constraint Architecture for AI Agents 11. Networked Agentic Organizations
Part IV: The Coding Agent Toolkit 12. Claude Code — The New Command Line for AI Engineers 13. Oh-My-Claude Code and the Plugin Ecosystem 14. Claude Code Best Practices — Patterns That Actually Work
Part V: The AI-Native Organization 15. Building AI-Native Teams 16. Language-Oriented Programming and Constrained Natural Language 17. The Future of Human-Agent Collaboration
Epilogue: The Right to Build Before Your Time
Clarity Forge : Local coding agent done right
An OpenSpec × Grill Mini Book
The Clarity Forge: Local AI, Done Right
The market is drowning in skill packs, plugin bundles, MCP servers, and "ultimate" prompt collections. They sell well for the same reason ab-roller infomercials sell well: they look like the thing that will fix you. They are not the thing that will fix you.
What fixes you is a small set of artifacts that capture intent before code, and a small set of prompts that move work between those artifacts predictably. Everything else is decoration.
The Clarity Forge is six stages and six prompts. That is the whole pipeline. You can run it on a weekend toy. You can run it on a 200k-LOC microservice. The artifacts scale; the discipline does not change.
What You Get
- The six-stage pipeline — OpenSpec Bootstrap → Grill-Me → Grill-With-Docs → ADR Grill → Tailored Emission → Dispatch → Verify-or-Escalate.
- Six copy-paste glue prompts — the connective tissue between stages, deliberately spare so the work lives in the artifacts, not the prompts.
- The hybrid Architect / Contractor split — frontier model (Opus, GPT-5, Sonnet 4.6+) writes the plan; open-weight local model (Gemma 4, Qwen 3) executes against it.
- Deep dives on the two highest-leverage schemas —
intent-driven(Gherkin specs + ADRs) andspec-driven-with-adr(standard specs + ADRs). - A worked example — passkey login, end to end, with a real ADR draft.
- An anti-pattern catalog — the shortcuts that look like the forge but quietly destroy it.
- A printable one-page reference card.
Who It Is For
- Engineers who use Claude Code, Cursor, Codex, or any coding agent on real production codebases.
- Tech leads tired of explaining to stakeholders why eight hours of agent execution produced code nobody can defend.
- Teams who want to run local open-weight models for execution without giving up frontier-grade reasoning for planning.
- Anyone who has felt the quiet erosion of confidence that comes from shipping AI-generated code with no audit trail of why it was decided.
This is a field guide, not a manifesto. Every prompt is runnable. Every stage produces a versionable artifact. You can be running the pipeline on a real change by Monday morning.
Companion to The Clarity Engineer
This mini book is the working pipeline. The full framework — clarity trading, world models, intent documentation, agent identity, networked agentic organizations — lives in the parent book:
📖 The Clarity Engineer: Code Is the Side Effect by Volodymyr Pavlyshyn — Leanpub · also on Amazon.
The Clarity Engineer names the discipline. The Clarity Forge gives you the working version on a single page.
About the Author
Volodymyr Pavlyshyn writes and builds at the intersection of agent orchestration, AI engineering discipline, and the durable artifacts that make software teams legible to themselves. He is the author of The Clarity Engineer and the maintainer of the OpenSpec schema family that this book documents.
Graph Engineering: The Loop That Remembers
The Loop That Remembers
Graph Engineering for Multi-Agent DevelopmentEveryone is building loops. Generate, critique, revise. Tools, worktrees, skills, sub-agents. The five pieces are well understood and widely documented — and every version of the list ends with a shrug: and you'll want some kind of memory, a scratchpad, a NOTES.md.
That shrug is the whole problem.
The memory is not the sixth piece of the loop. It is the thing the loop exists to produce.
This mini book takes that inversion seriously and follows it all the way down. It picks up where The Clarity Forge left off — with lat.md/, the lattice of ADRs, vocabulary, invariants, patterns, and principles — and finishes the job: turning a directory of Markdown files into a queryable, typed, provenance-bearing metagraph that many agents read from and write to at once, wired into every stage of the OpenSpec pipeline.
What You Get
- The two-graph distinction — why every serious agentic system needs a work graph (what happened) and a knowledge graph (what is true), why collapsing them destroys both, and the exactly two predicates that bridge them.
- The ladder — loop, chain, swarm, DAG, knowledge graph — with what each one externalises and a six-question decision procedure for picking a rung.
- A complete schema — twelve node types, eleven authored predicates across two planes, two derived relations, four layers, and five graph invariants you can write a linter against.
- Lattice metagraphs — why the forge lattice was a metagraph from day one, the three reification patterns that matter, and how to implement it in Markdown plus 300 lines of indexer instead of a database that does not exist.
- Semantic Spacetime for the lattice — the four fundamental relations, the discovery that the forge's five predicates are blind in exactly one direction, and pragmatic proximity as the mechanism that serves seven pipeline stages from one graph.
- The seven-step context builder — bounded, typed, time-filtered retrieval under a token budget, with stable edge IDs so answers can cite.
- The grounded evaluator — replacing "looks good" with a structured verdict that names the missing edge.
- The rewired pipeline — every forge stage with its graph reads and writes, and an archive command extended from mint → touch → resolve to mint → touch → resolve → link → check.
- Swarm coordination via promise theory — write scopes, correlated errors, reducer contracts, and why worktree isolation is necessary and nowhere near sufficient.
- A six-step build path with an exit criterion at every step, from one reflective loop on Day 1 to a graph-grounded swarm by Month 2.
- A full chapter on when not to build any of this.
Who It Is For
- Engineers running Claude Code, Cursor, Codex, or any coding agent unattended, who have noticed that the loop ships code and loses reasoning.
- Teams whose
lat.md/lattice has outgrowngrep— more than a hundred nodes, more than one writer. - Anyone who has come back to forty green commits and could not say why the retry budget is three.
- Knowledge-graph practitioners who want the agentic-workflow application rather than another survey.
This is a field guide. Every schema is implementable, every prompt is runnable, and the whole thing runs on Markdown files if you want it to — the graph index is disposable and rebuilds in seconds.
What It Is Not
It is not a survey of agent frameworks, a defence of any graph database, or an argument that every team needs a knowledge graph. Chapter 12 spends most of its length arguing the opposite, because the failure mode of this decade is not too little structure — it is structure adopted for its own sake.
If a NOTES.md and a disciplined ADR log already let you trace every important output to an objective, a plan, an artifact, a source, a graph path, an evaluator decision, and a bounded execution record, then you are done, and this book will tell you so.
The Series
📖 Clarity Engineer: Code Is the Side Effect — the discipline.
🔨 The Clarity Forge — the pipeline. 🕸
The Loop That Remembers — the memory.
Also relevant: Semantic Space Time for AI Agent Ready Graphs, Beyond Context Graphs, Temporal Aware AI memory, and LadybugDB for Edge Agent AI memory.
About the Author
Volodymyr Pavlyshyn writes and builds at the intersection of agent orchestration, knowledge representation, and the durable artifacts that make software teams legible to themselves. He is the author of Clarity Engineer, The Clarity Forge, and a series of books on graph-based memory for AI agents.
Earn $8 on a $10 Purchase, and $16 on a $20 Purchase
We pay 80% royalties on purchases of $7.99 or more, and 80% royalties minus a 50 cent flat fee on purchases between $0.99 and $7.98. You earn $8 on a $10 sale, and $16 on a $20 sale. So, if we sell 5000 non-refunded copies of your book for $20, you'll earn $80,000.
(Yes, some authors have already earned much more than that on Leanpub.)
In fact, authors have earned over $15 million writing, publishing and selling on Leanpub.
Learn more about writing on Leanpub
Free Updates. DRM Free.
If you buy a Leanpub book, you get free updates for as long as the author updates the book! Many authors use Leanpub to publish their books in-progress, while they are writing them. All readers get free updates, regardless of when they bought the book or how much they paid (including free).
Most Leanpub books are available in PDF (for computers) and EPUB (for phones, tablets and Kindle). The formats that a book includes are shown at the top right corner of this page.
Finally, Leanpub books don't have any DRM copy-protection nonsense, so you can easily read them on any supported device.
Learn more about Leanpub's ebook formats and where to read them
Write and Publish on Leanpub
You can use Leanpub to easily write, publish and sell in-progress and completed ebooks and online courses!
Leanpub is a powerful platform for serious authors, combining a simple, elegant writing and publishing workflow with a store focused on selling in-progress ebooks.
Leanpub is a magical typewriter for authors: just write in plain text, and to publish your ebook, just click a button. (Or, if you are producing your ebook your own way, you can even upload your own PDF and/or EPUB files and then publish with one click!) It really is that easy.