Activity
Mon
Wed
Fri
Sun
Dec
Jan
Feb
Mar
Apr
May
Jun
Jul
Aug
Sep
Oct
Nov
What is this?
Less
More
Clief Notes
56k
5.0
Free
13 contributions to Clief Notes
Retrofitting a complex, long-term Go IAM project to ICM (and stopping AI loops)
I’ve been building VK Auth (an idiomatic Go Identity & Access Management engine) for around a decade. Recently, I retrofitted the entire codebase onto our ibe-workflow-template (first introduced on this forum) — combining Jake’s ICM principles, Karpathy’s Claude rules, and Vigil Keep’s Intent-Based Engineering (IBE). It wasn’t smooth sailing out of the gate, and solving the biggest failure mode taught me a lesson worth sharing here. 🏊‍♂️ The Failure Mode: Swimming Halfway Across the River When migrating core architectures, the AI kept suffering from context confusion and mechanic fixation. The hardest problem was moving from single atomic writes on the authorization tree to a phased write mechanism that never violates invariants (yielding atomic writes in the best case and eventual consistency in the worst). Because this mechanism has irreducible complexity—the entire structure has to be in place before any of it works—the AI would get halfway through the refactor, lose its footing when intermediate checks failed, get disoriented, and swim right back to the shore it started from by reverting to the old architecture. 🛠️ The Fix: A 3-Way Resolution Mechanism (No Looping) To stop the agent from thrashing or reverting at the implementation layer, I enforced a strict three-step resolution ladder with zero looping: 1. Forward Drive: Intent → Decisions (ADRs) → Design / Specs → Implementation 2. Backward Validation: Implementation is validated directly against Intent. When something breaks, feedback walks backwards up the ladder to the first rung capable of answering it: - Can't solve it in Implementation? There is a gap in Design / Specs. - Can't solve it in Design / Specs? There is a gap in Decisions (e.g., missing trade-off priority between performance and consistency). - Can't solve it in Decisions? You have conflicting or non-resolvable Intents. 3. Forward Remediation: Once the gap is patched at the right rung, execution drives back down to Implementation and concludes. If it still fails, it stops and mandates human intervention—no endless agent loops burning context.
0 likes • 2d
Indeed. With clearly defined intents, separated from mechanisms and architecture, and constraints defined as movable and immovable, the process has successfully concluded every time; every pass raises the correct issue at the correct rung and successfully concludes without the human in the middle safety halt. The IBE framework and Layered Capability Architecture also comes into play. It works extremely well with ICM and doesn't need deep domain knowledge in order to do proper domain modelling (as is the case with domain driven development and clean architecture). The PERFORMANCE results in VK Auth stands as testament to this. Achieving exceptional numbers ito of both throughput and tail latency, and this with plain idiomatic Go (we deliberately refrained from implementing hardware specific optimizations, such as for AMD infinity fabric, etc). It proves that ICM combined with proper engineering discipline (IBE and Layered Capability Architecture) results in AI Augmented Engineering over vibe-coded AI slop. Knowledge with understanding vs knowledge without understanding (if I can borrow from the book of Job).
0 likes • 1d
I wrote a short post on dev.to regarding the project, specifically the throughput numbers of 27M-30M auth req/s and 20-25m authz req/s, the RWMutex wall and why we selected it over lock-free structures. You can read it here: https://dev.to/zanicar/how-i-built-a-30m-reqs-zero-alloc-iam-engine-in-go-and-hit-the-rwmutex-wall-243o
🛠️ New tool: ICM Architect
I explain the details about it on today's high tea . I built a Claude skill that turns a process, an idea, or a messy folder into an ICM workspace. The folder structure does the orchestration. Numbered folders carry the order, the hierarchy scopes context, and plain markdown files hold state. One agent walks the right files at the right time and does the work a multi-agent setup would. Repo: github.com/RinDig/icm-architect 📦 What it does Two modes. 🔨 Build. You describe your work and it pulls out the structure already sitting in how you talk about it. The stages, the points where you stop and check, what stays the same every run versus what is new. Then it picks one of five proven forms and scaffolds the smallest workspace that carries the job. ♻️ Restructure. Point it at a folder, repo, or vault you already have. It reads every file, sorts each one by role, shows you a migration map, waits for your yes, then moves and checks the result. 🧩 The five forms Pipeline, umbrella, record library, knowledge bundle, context map. They mix and nest, so most real workspaces use more than one. ✅ The walk test Every result gets checked cold. An agent with no memory has to open the root, find its way, act, and report status from the files alone. If it can't, the structure gets fixed until it can. ⚙️ How to use it You can honestly just tell claude to download it from the link, but if you're using codex or something else it will just have to restructure the claude.md to agents.md Or if you want to do more Hands-On install Claude Code: drop the folder in ~/.claude/skills/icm-architect/, then say "ICM this" or "build me a workspace for X." Claude apps: zip the folder and upload it under Settings, then Capabilities. Fork it, break it, tell me what you built. 👇
3 likes • Jul 20
@David Graham Intent-Based Engineering is what keeps it preserved (review the philosophy at https://vigilkeep.net). It is about explicit intent, constraint management and decision records baked into ICM. This prevent / mitigates the archaeological software problem (system entropy that obfuscate the why behind decisions). Every session starts with clear intent within the ICM framework, every action / decision records it as decision records and within the overall project / sub-project STATUS.md, so it is baked into the claude code's (or whatever agent harness you use) context. GitLab is open source and not Microsoft...
1 like • Jul 28
@David Graham the ibe workflow now supports composition and decomposition. Projects can be merged and split as a result of using IBE with ICM, i.e. self describing recursion architecture. I would recommend retrofitting your modules to the ibe workflow (latest is v0.7) and pointing claude from a parent context (the repo where you want them stiched together) to initiate the stitching...
Claude Code IBE Workflow Template (v0.3.0)
https://gitlab.com/vigilkeep/ibe-workflow-template Still in validation. The template gives Claude Code projects a repeatable structure for holding onto intent across sessions and across contributors, built on three ideas working together: IBE (Intent-Based Engineering, see https://vigilkeep.net) for keeping the "why" attached to the work, not just the "what"; Van Clief's ICM (Interpretable Context Methodology) for making that context legible rather than buried in someone's head; and Karpathy's behavioral principles for keeping the agent's day-to-day conduct predictable and scoped. Two files carry state: STATUS.md is the canonical current-position snapshot, overwritten each session and meant to be read cold by anyone (or any model) picking up the work. STATE.md is a personal, per-workstation session log — useful, but not something the project can rely on to bridge between machines or people, which is the gap the "consolidation before commit" rule exists to guard against. The template itself is compositional: a routing table maps task types (orient, plan, create, review, decide, debug, document, upgrade) to the workspace files and skills they need, so projects load only what's relevant instead of the whole thing at once. Newest piece is the no-code upgrade path (ADR-007): a versioning scheme so projects that instantiated an earlier copy of the template can pull in later refinements without a full re-adopt. Beyond the initial pilot (which included a complex multi-project organization), it's now been run live across an additional three real adopting projects — spanning both website and greenfield-project contexts — with all three upgrading cleanly. That's enough signal to call the upgrade path validated, not just designed.
0 likes • Jul 17
With the workflow rules. On commit, rule 5 triggers to ensure all touched and affected files are in sync, i.e. no stale references or conflicting states. This ensures the project always remain 100% self describing with STATUS.md reflecting the latest committed state. STATE.md can be omitted or empty, this is expected if you have a fresh clone of your repo on a new workstation. STATE.md will contain the workstation log to boost momentum and track what was last worked on in an individual capacity. The workflow will always check the latest commit hash versus the one last updated in STATE.md; this is the staleness trigger;
Built a reusable Claude Code project template that wires Jake's three-layer routing system into a full session architecture.
The template integrates three frameworks: Van Clief's routing (the structural backbone), Karpathy's behavioral rules (think before acting, minimum viable scope, surgical changes, goal-driven execution), and IBE intent preservation (the "why" behind every decision). Each tier has a clear job — CLAUDE.md routes, workspace context files carry domain knowledge, skills wire selectively per task. The core addition on top of Jake's routing: a session state pattern (STATE.md) that eliminates cold-start friction. Each session closes by setting the next session's intent. Work becomes a directed sequence rather than a series of isolated conversations. Results from two validations (a meta-framework design project and a non-software operational coordination project): - Zero context re-establishment at session start - Zero intent-misaligned rework - Second project stood up in ~25 min on first attempt, no structural modifications needed Template is public: https://gitlab.com/vigilkeep/ibe-workflow-template Happy to share the ADR that documents the one deliberate deviation from 3.3 guidance (CLAUDE.md runs ~70 lines instead of 40–50 — there's a specific reason).
0 likes • Jun 12
@Patrice Roatan Quebecois this may be useful in some instances, but in our team we often work on different parallels. Having a project level next intent serializes this. If there is a serial dependency in your project you will certainly benefit. My idea is to remain flexible and adaptable to multiple scenarios, so we go with the one that is least prescriptive / restrictive. Please bring some case studies regarding your experiences, friction points and successes. They'd be most welcome!
0 likes • Jul 16
The workflow template has been upgraded to v0.3.0 and now includes a no-code upgrade path; pilot tested against both a clean fresh project and a complex multi-project organization. Additionally tested against another 3 projects with clean upgrades, fully managed through context alone.
🏁 Foundations 4.5 Check-In
You just saw how context changes per task. Vote below, then tell us in the comments: what two areas of your work did you set up, and did Claude behave differently in each one?
Poll
321 members have voted
0 likes • Jun 4
I combined this with Karpathy's CLAUDE principles and Vigil Keep Intent-Based Engineering Framework. Tested with brand new project, and tested with 8 retrofit projects under one organization. Works very well so far. Limited testing within multi-user environment. Check it out https://gitlab.com/vigilkeep/ibe-workflow-template. Feedback welcome.
1-10 of 13
Billa Coetsee
3
16 points to level up
@billa-coetsee-5912
Seasoned Systems Architect and Technology Executive leading technical strategy and implementation across diverse organizations.

Online now
Joined May 21, 2026
ENTJ
South Africa
Powered by