Inside isacomp
Premier Issue
April 2026
Vol. 01 · No. 01
Designing
processors,
differently.

A field report from the front line of ISA-first hardware design — and the human–AI methodology that is reshaping how processors come into the world.

The SabbaticalHow one researcher and one model built 600,000 lines of working processor compiler in a single term.
Seven SpecialistsMeet the advisory team built into the isacomp-guru skill — and learn when to call each one.
The Cowork PluginEleven slash commands that compress a directed-compilation session into a working day.
thestrategycafe.com · Strategy Café Press Published in collaboration with the isacomp project & UCSB ArchLab
Inside isacompPremier Issue · April 2026
In this issue

Contents & Editorial

  • 03Why isacomp matters — the sabbatical project that questioned how processors are builtFeature
  • 05How directed compilation works — from .isa file to working RTL in seven phasesFeature
  • 07By the numbers — the scale of what one collaboration producedData
  • 08Inside the optimisation library — twenty-seven moves, one designerDeep dive
  • 09Meet isacomp-guru — the seven-specialist advisory skillSkill
  • 10The Specialist Roster — persona cards for the teamProfiles
  • 12Workbench Mode — the seven-phase guided sessionMethodology
  • 13The Workbench Tools — Session Planner, Graph Explorer, AI Design AdvisorTools
  • 14The Cowork Plugin — eleven slash commands for experienced usersPlugin
  • 15Looking ahead — distribution, licensing, and what comes nextRoadmap
  • 16Colophon, credits, and acknowledgementsBack cover

How to read this issue

The early pages set the scene. The middle pages introduce the framework and the advisory skill. The closing pages cover the workbench tools and the Cowork plugin. Each section is self-contained — feel free to dip in by topic. Source citations sit at the back; quotations are drawn from the LATTE 2026 paper and the project repository as of April 2026.

Page 02thestrategycafe.com
Feature · OriginInside isacomp · Premier Issue
The Sabbatical Project

What if you could
compile a processor
like a program?

A short, plain-English account of why isacomp exists, what it changes, and the human–AI collaboration that produced it.

Processor design has, for forty years, been written in hardware-description languages. A designer wades into Verilog or VHDL, translates an instruction-set architecture into wires and registers, and then shepherds the result through synthesis, simulation, layout, and verification. The instruction-set specification — the actual contract with the software ecosystem — sits in a document somewhere, kept in step with the implementation by hand and by hope.

Prof. Jonathan Balkind, who runs the ArchLab at UC Santa Barbara and previously co-led the OpenPiton manycore platform at Princeton, started his Fall 2025 sabbatical with a different question. What if the instruction-set specification was the source code? What if a processor was something you compiled from a per-instruction description, the way a programmer compiles a function? What if the optimisations a designer applies — pipelining, hazard resolution, branch prediction, register renaming — were software passes you could sequence, profile, and undo?

The answer is isacomp: a research-grade ISA compiler that takes per-instruction .isa files written in a small domain-specific language, extracts each instruction as a single-cycle resource graph, lets the designer apply microarchitectural optimisations as algorithmic transformations on that graph, and then emits Verilog (or one of eight other RTL targets) automatically.

Twenty-two instruction-set architectures are now supported. Nine of them — including RV32IMA, RV64IMA, MIPS32, OpenPOWER LCS, Alpha EV56, both PA-RISC variants, OpenRISC ORBIS32, and SuperH — boot Linux on the single-cycle implementation. Twenty-seven optimisation modules sit in the opt/ library, with twenty-one of them tabulated in the LATTE 2026 paper. Nine RTL backends produce working hardware.

“What is special is not that a compiler can produce a processor. It is that the compiler treats the ISA specification as the program — and the optimisations as passes you can choose, sequence, and reason about.” — from the editor's notes

The methodological story matters as much as the technical one. The 600,000-line codebase was authored by Claude under Prof. Balkind's direction during a single sabbatical term. He wrote the architectural decisions and reviewed every commit; the model produced the implementation. The acknowledgements in the LATTE 2026 paper credit Anthropic for enabling the work and Claude for authoring the codebase — an unusually candid statement of how the artefact came to exist.

That symmetry — a tool built with Claude, with an advisory skill that uses Claude to help others use it — is part of why this magazine exists. The method is reproducible. The scale is the surprise. And the posture — open about how the work was done, careful about what is verified, generous about what is shared — is something the field can learn from.

Page 03Origin story
Feature · OriginInside isacomp · Premier Issue

Why this matters

Strategic view

For the academic community, isacomp lowers the barrier to processor research. Adding a new instruction-set architecture becomes the work of writing per-instruction specifications, not the work of writing an entire RTL implementation. A novel optimisation becomes a new module in opt/ rather than a wholesale redesign. Comparing two pipeline depths becomes two configurations, not two projects.

For educators, the framework changes what is possible to teach. A computer architecture lab can explore real microarchitectural decisions on a working pipeline in a single class — pipelining the ISA, comparing stall vs bypass for hazards, adding branch prediction, generating Verilog, and running the result. UCSB's CS 154 module is the immediate beneficiary; equivalent courses elsewhere are the next.

For the industry, the story is more nuanced. Production processor design teams have decades of accumulated tooling that isacomp does not replace. But the principle — treat the ISA specification as the source of truth, manage the implementation as a sequence of intentional transformations — is one that production teams will recognise as overdue. Even if no commercial design ever ships through isacomp, the methodology travels.

For Anthropic and the wider community thinking about human–AI collaboration in technical work, isacomp is an unusually rich case study. It is large (600,000 lines of working code), it is verified (CI runs riscv-tests on multiple configurations and Linux boots on nine), it is documented (the LATTE 2026 paper is a clear account), and it is open about its methodology. There is no claim that the model worked alone — Prof. Balkind's direction is what shaped every algorithmic decision. But there is also no pretence that a single human wrote every line in a sabbatical term.

Three audiences should pay attention. The first is researchers who care about microarchitecture, formal methods, or compiler-driven hardware design — for them, isacomp is a research substrate. The second is educators looking for a teachable, hackable, complete pipeline. The third is innovation funders and strategic readers who want to understand what AI-augmented systems engineering looks like when it is done with care.

This magazine is for all three.

22ISA architectures
From RV32IMA to subleq, from PA-RISC to MMIX. Nine boot Linux today.
27Optimisation modules
21 paper-tabled in LATTE 2026 plus six repository-only modules.
9RTL backends
Verilog primary; the others cover the long tail of HDL targets.
Page 04Origin story
Feature · MethodologyInside isacomp · Premier Issue
How directed compilation works

Specification → graph
→ optimisation → RTL.

A walkthrough of the loop the framework runs every time a designer asks it to produce a processor.

.isa file Per-instruction specification (DSL) Resource Graph Single-cycle IR with merge logic Optimisation 27 modules in opt/ pipeline · sharing · memory temporal · fetch · ooo RTL Backends Verilog primary + 8 alternative HDL targets SMT verification & CI test suites run alongside every step The directed compilation loop

The compilation loop is, deliberately, small enough to hold in your head. A designer writes per-instruction .isa specifications in a small DSL — load, store, add, branch, each as its own file. The parser produces a single-cycle resource graph for each instruction. The graph merger combines those per-instruction graphs into a unified design. The optimisation orchestrator applies any sequence the designer chooses from the opt/ library — pipelining, hazard resolution, sharing, parallelisation, memory externalisation, branch prediction, register renaming, and more. The RTL backend emits the final implementation.

Around that loop sits the verification machinery. SMT-based equivalence checking runs at chosen checkpoints. Riscv-tests runs in continuous integration. Selected configurations boot Linux. Each layer answers a different question: does the optimisation preserve semantics, does the implementation pass the architectural test suite, and does the result run real software.

What the designer brings to this loop is judgment. The framework will not tell you whether to pipeline three stages or five. It will not tell you whether to resolve a hazard with a stall or a bypass. It will let you try both, compare the results, and make the call. The optimisation library is the menu; the designer is the chef.

That is why isacomp-guru — the advisory skill we will meet later — exists. The framework presents a vast option space. A designer who is new to it, or who is exploring an unfamiliar architecture, benefits from a team of specialists who understand the menu deeply.

Page 05Methodology
Feature · MethodologyInside isacomp · Premier Issue

Anatomy of a design

RV32I in seven steps

Below is the canonical entry-point sketch for a five-stage pipelined RV32I — the kind of design that a CS 154 lab can finish in a single sitting.

# 1. Parse and merge the per-instruction .isa specifications
merger = ResourceGraphMerger()
for name, path in rv32i_instructions.items():
    merger.add_instruction(name, path)
graph = merger.merge_graphs()

# 2. Externalise memory — a prerequisite for SoC integration
MemoryExternalisation(graph).apply()

# 3. Define pipeline cuts — the designer's "where"
cuts = {
    'IF/ID':  [find_edge('umem[pc]_rd', 'instr')],
    'ID/EX':  [find_edge('rf[rs1]_rd', 'r1'),
                find_edge('rf[rs2]_rd', 'r2')],
    'EX/MEM': [find_edge('res', 'dmem_wr')],
    'MEM/WB': [find_edge('dmem_rd', 'wb_data')]
}

# 4. Apply pipelining
PipelineTransform(graph).add_multiple_pipeline_stages(cuts)

# 5. Detect and resolve hazards (stall or bypass — the designer chooses)
hazards = HazardAnalyzer(graph).analyze_hazards()
HazardResolver(graph).resolve_all_hazards(hazards)

# 6. Branch prediction (optional — try with and without)
apply_branch_prediction_not_taken(graph, pc_node_id='pc_wr')

# 7. Generate working RTL
VerilogGenerator(graph).generate("rv32i_5stage.v")

Read it once and the full design conversation is visible: specify, merge, externalise memory, decide where to cut the pipeline, decide how to resolve hazards, decide whether to predict branches, emit RTL. Each line is a decision the designer owns. Each module is a piece of well-tested machinery the framework provides.

Where the work actually happens

Most of the design intelligence lives in steps 3, 5, and 6 — where the pipeline is cut, how each hazard is resolved, and which speculation strategies are applied. Steps 1, 2, 4, and 7 are largely mechanical. The framework's value is that it makes the intelligent steps the focus, not the bookkeeping.

Page 06Methodology
Data · By the numbersInside isacomp · Premier Issue
By the numbers

The scale of one collaboration.

Twelve numbers that capture what was produced, where it lives, and what it has been validated against. All figures from the LATTE 2026 paper and the April 2026 repository checkpoint.

600K+Lines of source
Across Python engine, Rust core, .isa specifications, and assembly tests.
200K+Python SLOC
The primary engine: parser, IR, merger, builders, timing.
300K+.isa SLOC
Per-instruction specifications across 22 architectures.
50K+Rust SLOC
The emerging Rust reimplementation with Python bindings.
40K+Assembly tests
Per-architecture test suites including riscv-tests integration.
22ISAs supported
From production RV64IMA to historical PDP-11/70 and pedagogical subleq.
9Linux-bootable
Single-cycle implementations that boot a real Linux kernel.
9RTL backends
Verilog primary plus eight alternative HDL emission paths.
27Optimisation modules
21 in LATTE 2026 Table 1 plus six repository-only additions.
7Phases per opt
Universal seven-phase pattern across the optimisation library.
7Specialists in the skill
isacomp-guru's advisory team, calibrated to the project's domains.
11Slash commands
The Cowork plugin's compressed command surface for experienced users.

What is not in the numbers

The numbers above describe the artefact. They do not describe the daily decisions, the productive disagreements, the rejected experiments, or the lineage of papers that informed the design. Those are in the LATTE 2026 paper, in the repository commit log, and in conversations the project team is still having. This magazine touches each in turn.

Page 07By the numbers
Deep dive · opt/Inside isacomp · Premier Issue
Inside the optimisation library

Twenty-seven moves,
one designer.

A guided tour of the opt/ directory and the design goals each module addresses. The library is what gives a designer their menu of intentional transformations.

FamilyWhat it doesRepresentative modules
pipeline/Cuts a single-cycle design into a pipeline; resolves hazards by stall or bypass; supports dual-issue.pipeline_transform · hazard_analyzer · hazard_resolver · dual_issue
sharing/Identifies redundant operations or resources and merges them — the lever for area reduction.operation_sharing · resource_sharing
memory/Manages the memory hierarchy: cache insertion, TLB, externalisation for SoC integration, port management, gating.memory_externalization · cache · tlb · port_management
temporal/Re-times the work across cycles — serialise to save area, parallelise to gain throughput, multi-cycle for critical path relief.operation_serialization · operation_parallelization · multi_cycle
fetch/Front-end intelligence: branch prediction, BTB, RAS, instruction buffer.branch_prediction · btb · ras · instruction_buffer
ooo/Out-of-order machinery — register renaming as the foundation.register_renaming
top-levelCross-cutting transforms: retiming, architectural retiming, plus six repository-only modules pending paper-level documentation.retiming_optimization · architectural_retiming · alu_integration · isa_state_gating · macro_op_fusion · mux_deduplication

The library is laid out by family because design conversation is. A designer rarely asks "which module should I run next" in the abstract; they ask "I need more throughput" or "I need less area" or "I need to integrate this with a memory system." The family layout maps to those questions.

Five of the modules — alu_integration, isa_state_gating, macro_op_fusion, mux_deduplication, and the two memory gating variants — are present in the repository but were not tabulated in the paper's twenty-one. These sit at MEDIUM confidence in the advisory skill until Prof. Balkind confirms their intended scope. Transparency about that tier matters; it is the difference between a recommendation a designer can act on and one they should only experiment with.

“Optimisations are not magic. They are well-named software passes — choose them, sequence them, profile them, undo them.”

Sequencing matters as much as selection. Memory externalisation typically runs first when SoC integration is the goal. Pipelining usually precedes hazard resolution because hazards depend on the cuts. Branch prediction typically follows the basic pipeline. And verification checkpoints sit between the major stages — a designer who skips them is gambling that nothing they did broke semantics.

The advisory skill we meet on the next page is, in large part, a sequencing assistant. The library gives you the moves; the team helps you order them.

Page 08Deep dive: opt/
Skill · isacomp-guruInside isacomp · Premier Issue
Meet the skill

isacomp-guru:
conversational design,
seven specialists deep.

A quality-tier "Super Premium" advisory skill that runs in Claude Chat. Built to mirror the structure of the framework it explains, with productive tensions wired in.

isacomp-guru is what happens when an advisory skill is built with the same care as the artefact it serves. It is grounded in the LATTE 2026 paper, in a verified April 2026 clone of the repository, and in the documented algorithmic patterns — not in vibes about how a compiler "probably" works. Every substantive recommendation cites a source.

Structurally, the skill is modular. A thin SKILL.md file holds the orchestration logic — mode detection, team roster, routing, quick-lookup tables. Seven persona files in personas/ hold the deep specialist content. Six reference files in references/ hold the catalogue of optimisations, the seven-phase pattern, the ISA coverage table, the workbench mode specification, the attribution framework, and the Knowledge Update Protocol.

Six operating modes adapt the skill to the situation. Expert Consultation handles single questions. Team Discussion (Observation or Participation) handles deliberation. Teaching Mode handles classroom-style explanation. Research Frontier Mode handles speculative or novel topics with explicit confidence markers. Workbench Mode handles a full directed-compilation session.

Design principles

Three principles shape the skill. Repository grounding: every recommendation anchors to source files or documented algorithms, not to extrapolation from the paper alone. Productive tensions: specialists disagree on purpose, surfacing real trade-offs. Confidence markers: HIGH, MEDIUM, and LOW are used explicitly so a designer always knows whether they are acting on validated material or experimental terrain.

At a glance

Version1.1.0-phase1
Quality tierSuper Premium
CapabilityCore + Pro + Tutor + Guru
Specialists7 personas
Modes6 operating modes
Reference files6 in references/
Adjacent skillopen-piton-guru
Repository basisApril 2026 clone
Paper basisLATTE 2026

When to use which mode

Expert Consultation — default Q&A Team Discussion — multi-perspective Teaching — classroom-friendly Research Frontier — speculative Workbench — full design loop

Adjacent skill

For manycore integration beyond the BYOC adapter boundary, isacomp-guru hands off to open-piton-guru — the corresponding skill for the OpenPiton platform. The two were built together and are designed to interoperate.

The Knowledge Update Protocol — a maintenance feature, not a footnote

One of the skill's distinguishing features is a formal five-step protocol for incremental updates: characterise the new material, align it to personas, anchor citations, apply edits in place, and validate and log. The point is that a skill which evolves with its underlying project should evolve cleanly — not by accreting drift but by following a discipline. The protocol lives in references/knowledge_update_protocol.md and is invoked through the Cowork plugin's /isa-knowledge-update command.

Page 09Skill: isacomp-guru
Profiles · The teamInside isacomp · Premier Issue
The Specialist Roster

Seven specialists,
built to disagree productively.

Persona cards for the isacomp-guru advisory team. Each specialist owns a domain of the framework and brings a distinctive analytic style. The disagreements are the feature.

AM

Dr Aria Matsuda

ISA Specification Architect

Owns the .isa DSL, the grammar, and the per-architecture state model. Aria's question is always "what does the specification actually say?" Lead on every Phase 1 review.

RO

Dr Rafael Osei

Resource Graph Analyst

Owns the IR — the graph extraction, the merger, timing inference, the orthogon constructs. Asks "what does the graph look like before you start changing it?" before any optimisation runs.

IL

Dr Ingrid Larsen

Optimisation Strategist

Owns the optimisation library and the sequencing decisions. Frames every design conversation in terms of the objective function. Lead on Phase 4.

TV

Dr Tomás Vega

Pipeline & Hazard Engineer

Owns pipelining, hazard analysis, hazard resolution, branch prediction. The team's pragmatist — pipeline first, instrument heavily, iterate.

NO

Dr Nadia Okonkwo

Verification & Validation Lead

Owns SMT verification, riscv-tests integration, CI workflows, Linux boot evidence. Will hold the line when the team wants to skip a verification checkpoint.

YT

Dr Yuki Tanaka

Accelerator & Custom ISA Specialist

Owns custom ISAs (Zarf, Hobbit, subleq), out-of-order machinery, accelerator-from-graph mapping. The team's frontier explorer.

WH

Dr Will Hartley

RTL Egress & SoC Integration

Owns the nine RTL backends, memory externalisation, the OpenPiton/BYOC pathway. The team's bridge to the world outside the core.

+1

Productive tensions, by design

The team mechanic

Aria↔Rafael (completeness vs pragmatism) · Rafael↔Tomás (graph vs iteration) · Ingrid↔Nadia (exploration vs verification) · Yuki↔Will (frontier vs proven) · Tomás↔Nadia (bypass-first vs stall-first).

Page 10The team
Profiles · Team in motionInside isacomp · Premier Issue

The team in motion

A worked example

To see the team work, picture a designer who wants to add a new instruction-set architecture to isacomp. The first conversation is with Aria: what is the state model, what aspects need declaring, what does each instruction look like? The second is with Rafael: how do the graphs merge, where does the timing land, are there orthogon patterns worth using? Ingrid then enters when the goal becomes "build a pipeline" — and Tomás joins for the cuts and the hazards.

Nadia is alongside the whole way, asking which verification tier each decision sits in. Will appears when memory externalisation comes up, and again at RTL emission. Yuki joins when the architecture is genuinely novel — a custom ISA, an accelerator pattern, an out-of-order experiment.

A few sample routing decisions

If you ask…The skill routes to…Mode it tends to enter
"What does the aspect declaration in .isa mean?"AriaExpert Consultation
"Walk me through compiling a five-stage RV32I."Workbench Mode (all)Workbench
"Help my undergraduates understand pipelining."Tomás + AriaTeaching
"What if I treated this graph as a systolic accelerator?"Yuki + RafaelResearch Frontier
"We disagree — should we bypass or stall?"Tomás + NadiaTeam Discussion
"How do I integrate this with OpenPiton?"Will → open-piton-guruExpert + handoff
“The point of multiple specialists is not that each one knows more than you. It is that, together, they ask the questions you would otherwise have to discover yourself.”

Productive tensions are the feature. A solo expert can give you an answer; a balanced team gives you the trade-offs. For research-grade work — and for any work where the next decision shapes the cost of the one after it — that is the more useful service.

Page 11Team in motion
Methodology · Workbench ModeInside isacomp · Premier Issue
The seven-phase journey

Workbench Mode:
directed compilation,
guided.

When a designer is ready to take a specification all the way to RTL — with the team alongside — the skill enters Workbench Mode and runs a seven-phase guided session.

1Specification ReviewAria
2Extract & MergeRafael
3Goal ClarificationIngrid
4Optimisation SequencingIngrid + Tomás
5Hazard StrategyTomás
6Verification PlanningNadia
7Egress & IntegrationWill

Phase 1 — Specification Review. Aria walks the .isa state inventory and any aspect declarations. Are the per-instruction specifications complete enough to extract from? Are there state model decisions the designer has not yet thought through? The output is an inventory artefact.

Phase 2 — Extraction & Merge Assessment. Rafael characterises the resource graph the merger will produce. What is the merge quality? Where are the long edges that will dominate timing? The output is a merge-quality artefact.

Phase 3 — Design Goal Clarification. Ingrid converts the design goal into a testable form. "I want low area" becomes "I am willing to trade up to a 30% throughput cut for a 50% area reduction." The output is a goal register.

Phase 4 — Optimisation Sequencing. Ingrid and Tomás work out the order of opt modules to apply. Memory externalisation usually first if SoC integration is in scope. Pipelining before hazard resolution. The output is an opt sequence.

Phase 5 — Hazard Strategy. Tomás makes per-hazard stall versus bypass decisions, with Nadia challenging where correctness is not obvious. The output is a hazard decision log.

Phase 6 — Verification Planning. Nadia assigns each major decision to a verification tier — SMT equivalence, riscv-tests, Linux boot evidence — and flags anything that cannot be validated within current infrastructure. The output is a verification plan.

Phase 7 — Egress & Integration. Will selects the RTL backend, plans the SoC integration handoff, and points to the OpenPiton/BYOC pathway if the design is heading into a manycore system. The output is an egress configuration.

Iteration is built in

Workbench Mode is not a waterfall. If Phase 5 reveals that the pipeline depth chosen in Phase 4 is wrong, the session loops back. If Phase 6 finds a verification gap, the design returns to Phase 4 with a new constraint. The session-closure artefact records the loops; the next session can pick them up.

Page 12Workbench Mode
Tools · Workbench SuiteInside isacomp · Premier Issue
The Workbench Tools

Three tactile companions
to the conversation.

isacomp-guru is conversational. The Workbench Suite is tactile. Together, they make a directed-compilation session something a designer can hold, sketch, and revisit — not just talk through.

01 · Session Planner

Track the loop

A browser-resident HTML/JS planner that mirrors the seven-phase pattern. The designer logs each phase's output, captures decisions, and persists state across sessions through localStorage. The point: a directed compilation session is a multi-day activity, and the planner gives it a home.

02 · Resource Graph Visualiser

See the IR

An interactive HTML/SVG explorer that renders resource graphs and the seven-phase optimisation pattern. Designed for before/after diagrams of an optimisation in flight — the kind of artefact that turns "I think this transform helps" into "here is what changed and why."

03 · AI Design Advisor

Call the team

A React tool calling the Anthropic API with an isacomp system prompt. The designer poses a specific challenge; the advisor invokes the persona logic from the skill and returns a structured recommendation. Useful when the designer wants the team's voice without leaving the workbench.

How they fit together

A workflow

A typical day looks like this. The designer opens the Session Planner and resumes the workbench session from yesterday — Phase 4 was unfinished. They walk through the candidate optimisation sequence with the planner's prompts. They pull up the Graph Visualiser to look at how the merger handled two specific instructions. They notice an edge they want a second opinion on. They fire up the AI Design Advisor, paste the relevant context, and ask Tomás and Nadia for a verdict. The advisor returns a recommendation; the designer records it in the planner; the session continues.

None of the three tools is required for using isacomp. The framework runs perfectly well from the command line. But for the kind of multi-session, multi-decision design work that real processors require, the tools turn a sequence of conversations into a coherent design record.

All three are HTML/JS, all single-file, all designed to be portable. The AI Design Advisor uses the Anthropic API directly, in the same pattern as the other example tools David maintains at thestrategycafe.com. The Graph Visualiser is pure SVG. The Session Planner uses localStorage so the designer's record survives a browser restart.

Page 13Workbench tools
Plugin · isacomp-coworkInside isacomp · Premier Issue
The Cowork plugin

isacomp-cowork:
eleven slash commands
for a working day.

For experienced users, the Cowork plugin compresses the directed compilation workflow into a small command surface. It is an additional interaction surface — not a replacement for the full skill.

The plugin is the Cowork counterpart to isacomp-guru. Where the skill runs a seven-persona team across six modes in Claude Chat, the plugin compresses the directed-compilation workflow into eleven slash commands an experienced designer can invoke directly in Cowork. The plugin connects to a local clone of the isacomp repository, verifies file paths against real repository state on each command, and explicitly signposts work that is better handled elsewhere.

Every phase writes a markdown artefact to the workspace folder. The artefacts persist between sessions and form the documentation trail for a design. A workbench session closes with a canonical resumption document that the next /isa-start resume picks up. The discipline is intentional: an experienced designer should not have to re-explain context they have already established.

Importantly, the plugin signposts out when the task changes character. Teaching, foundational, or research frontier requests are routed back to the full isacomp-guru skill in Chat. File-level semantics go to the local repository (with paths cited). Persistent visual state goes to the standalone Workbench Suite. Manycore integration beyond the BYOC adapter goes to open-piton-guru. The routing rulebook is in references/referral-map.md.

Behind the eleven commands sits a compressed companion skill, isacomp-methodology, that is kept in step with the upstream isacomp-guru through the Knowledge Update Protocol. When the upstream skill bumps, the plugin's compressed material is reviewed for drift. The cowork-plugin-transformer skill in the broader library is the canonical maintenance reference.

Command inventory

/isa-startTriage entry; link the local repo
/isa-specPhase 1 — Spec Review (Aria)
/isa-extractPhase 2 — Extract & Merge (Rafael)
/isa-goalPhase 3 — Goal Clarification (Ingrid)
/isa-optimisePhase 4 — Sequencing (Ingrid + Tomás)
/isa-hazardsPhase 5 — Hazard Strategy (Tomás)
/isa-verifyPhase 6 — Verification Plan (Nadia)
/isa-rtlPhase 7 — Egress (Will)
/isa-workbenchFull seven-phase guided session
/isa-knowledge-updateSeed a Knowledge Update session
/isa-referExplicit referral elsewhere

Typical flows

Novel design: /isa-start → /isa-workbench riscv32

Targeted iteration: /isa-start → /isa-optimise → /isa-hazards → /isa-verify → /isa-rtl

Skill maintenance: /isa-knowledge-update → carry the handover artefact into Chat with isacomp-guru loaded.

Plugin status

Version 0.1.0 — start of distribution. Built against isacomp-guru v1.1.0-phase1 and the April 2026 repository checkpoint. Expects iteration; feedback from Prof. Balkind and other experienced users will shape the 0.2.0 release. Distribution is currently personal / paused pending Prof. Balkind's review.

Page 14Plugin: isacomp-cowork
Roadmap · What's nextInside isacomp · Premier Issue
Looking ahead

Distribution, licensing,
and what comes next.

isacomp, the skill, the workbench, and the plugin are all in active development. Here is what is on the near horizon — and the open questions worth flagging.

Distribution posture

Public distribution of the advisory ecosystem is paused pending Prof. Balkind's review and testing. For now, sharing is on a personal basis to colleagues and collaborators who are positioned to test in real workflows. The CC BY-NC-SA 4.0 licence is the current candidate for the wider release — non-commercial research, education, and personal use welcomed; commercial use by separate arrangement.

This posture matches the project's research-grade origins. The artefact deserves real-world feedback from experienced users before going wide. The Knowledge Update Protocol is the mechanism for incorporating that feedback cleanly when it arrives.

Open confirmation items

Five items are open for Prof. Balkind to confirm and will tighten the skill's confidence markers when resolved: the purpose of the six repository-only optimisation modules; the role of the orthogon construct in the merger; the current Linux-boot status of M68K and i486; any expansion of the CI-validated Tier B set; and any post-paper optimisation modules landing during the active project phase. Each item is tracked in SKILL.md §8.

Roadmap by component

isacomp: the framework itself continues to evolve under Prof. Balkind. The Rust core's coverage is expanding; the WASM frontend prototype is in the GUI directory; new ISAs and optimisations will land as research demands. CI continues to validate the headline configurations.

isacomp-guru: v1.1.0-phase1 is the current skill release. A v2 is anticipated when sufficient new material accumulates to justify the lift, with a bridging mode to open-piton-guru as a planned addition. Updates flow through the Knowledge Update Protocol.

Workbench Suite: the three companion tools (Session Planner, Graph Visualiser, AI Design Advisor) are tracked in WORKBENCH_BUILD_SPEC.md. Sequencing is intentional — the deep skill first, then the workbench, so the workbench can use the skill's deeper context.

isacomp-cowork plugin: v0.1.0 is the start of distribution. The 0.2.0 release will reflect feedback from experienced users. The companion isacomp-methodology skill is updated through the Knowledge Update Protocol whenever the upstream skill bumps.

Why the Knowledge Update Protocol matters in the long run

An advisory skill that sits on top of an evolving research codebase will drift if it is not maintained with discipline. The five-step protocol — characterise, align, anchor, apply, validate — keeps the skill coherent as the underlying project grows. It is the difference between a skill that ages well and one that quietly stops being trustworthy. Building the protocol into the skill from version 1.1 was an intentional act, not an afterthought.

“The artefact is open about how it was made. The skill is open about what it knows and what it does not. The plugin is open about when it should hand off to something else. That posture is the methodology — and it is reproducible.”
Page 15Looking ahead
ColophonInside isacomp · Premier Issue
Closing thoughts

Built openly, advised carefully,
shared with intent.

A processor compiler that takes ISA specifications as its source code. An advisory skill built with the same care as the artefact it serves. A workbench suite that makes the conversation tactile. A Cowork plugin that compresses an experienced session into a working day. And a maintenance discipline that keeps all of this honest as it evolves.

Acknowledgements

The framework is the work of Prof. Jonathan Balkind at UC Santa Barbara's ArchLab, with collaborators acknowledged in the LATTE 2026 paper: Zachary D. Sisco, Harlan Kringen, Jingtao Xia, Sijie Kong, Naomi Rehman, Brian Li, Sarkis Ter-Martirosyan, Luke Herbelin, Joshua Gray, and Katie Lim. Anthropic, through Siddharth Mishra-Sharma, provided the Claude Max subscription that enabled the underlying development. Claude authored the 600,000-line codebase under Prof. Balkind's direction during the Fall 2025 sabbatical.

This magazine, the isacomp-guru skill, the workbench tooling, and the isacomp-cowork plugin were assembled by David Balkind at The Strategy Café, working with Claude. The skill draws its grounding from the LATTE 2026 paper and a verified April 2026 clone of the repository.

Colophon

Title
Inside isacomp — Premier Issue
Issue
Vol. 01 · No. 01 · April 2026
Editor
David Balkind
Publisher
Strategy Café Press, Glasgow
Built with
Claude (Anthropic), HTML, CSS, SVG; assembled in Cowork mode
Set in
Georgia (display + body), Helvetica Neue (sans), Fira Code (mono)
Sources
Balkind, Check out my sabbatical project, LATTE 2026; github.com/isacomp-project/isacomp (April 2026 clone); isacomp-guru SKILL.md and reference files; isacomp-cowork plugin README.
Licence
This magazine is shared on the same posture as the underlying project: personal distribution; CC BY-NC-SA 4.0 candidate for wider release pending review.
Contact
thestrategycafe.com · david.balkind@thestrategycafe.com

Made in Glasgow · Designed for Santa Barbara · Read everywhere

Page 16 · Back coverthestrategycafe.com