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.
.isa file to working RTL in seven phasesFeatureThe 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.
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.
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.
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.
Specifications become first-class. Optimisations become reorderable. Verification becomes layered. Comparisons become cheap. And the conversation between architect, compiler, and verifier becomes something a small team can hold in one head.
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.
A walkthrough of the loop the framework runs every time a designer asks it to produce a processor.
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.
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.
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.
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.
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.
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.
| Family | What it does | Representative 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-level | Cross-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.
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.
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.
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.
| Version | 1.1.0-phase1 |
| Quality tier | Super Premium |
| Capability | Core + Pro + Tutor + Guru |
| Specialists | 7 personas |
| Modes | 6 operating modes |
| Reference files | 6 in references/ |
| Adjacent skill | open-piton-guru |
| Repository basis | April 2026 clone |
| Paper basis | LATTE 2026 |
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.
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.
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.
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.
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.
Owns the optimisation library and the sequencing decisions. Frames every design conversation in terms of the objective function. Lead on Phase 4.
Owns pipelining, hazard analysis, hazard resolution, branch prediction. The team's pragmatist — pipeline first, instrument heavily, iterate.
Owns SMT verification, riscv-tests integration, CI workflows, Linux boot evidence. Will hold the line when the team wants to skip a verification checkpoint.
Owns custom ISAs (Zarf, Hobbit, subleq), out-of-order machinery, accelerator-from-graph mapping. The team's frontier explorer.
Owns the nine RTL backends, memory externalisation, the OpenPiton/BYOC pathway. The team's bridge to the world outside the core.
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).
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.
"You can't optimise what you haven't fully specified." — Aria · "Specify enough to start; the graph will tell you the rest." — Rafael · "Read the whole graph before touching the pipeline." — Rafael · "Get a working three-stage pipeline running first; refine the rest." — Tomás · "Bypass first, stall only when you must." — Tomás · "Stall first, prove correctness, then optimise to bypass." — Nadia · "Try the novel pattern; the framework lets you compare." — Yuki · "Validated pathways exist for a reason." — Will
| If you ask… | The skill routes to… | Mode it tends to enter |
|---|---|---|
"What does the aspect declaration in .isa mean?" | Aria | Expert Consultation |
| "Walk me through compiling a five-stage RV32I." | Workbench Mode (all) | Workbench |
| "Help my undergraduates understand pipelining." | Tomás + Aria | Teaching |
| "What if I treated this graph as a systolic accelerator?" | Yuki + Rafael | Research Frontier |
| "We disagree — should we bypass or stall?" | Tomás + Nadia | Team Discussion |
| "How do I integrate this with OpenPiton?" | Will → open-piton-guru | Expert + handoff |
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.
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.
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.
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.
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.
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.
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."
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.
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.
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.
/isa-start | Triage entry; link the local repo |
/isa-spec | Phase 1 — Spec Review (Aria) |
/isa-extract | Phase 2 — Extract & Merge (Rafael) |
/isa-goal | Phase 3 — Goal Clarification (Ingrid) |
/isa-optimise | Phase 4 — Sequencing (Ingrid + Tomás) |
/isa-hazards | Phase 5 — Hazard Strategy (Tomás) |
/isa-verify | Phase 6 — Verification Plan (Nadia) |
/isa-rtl | Phase 7 — Egress (Will) |
/isa-workbench | Full seven-phase guided session |
/isa-knowledge-update | Seed a Knowledge Update session |
/isa-refer | Explicit referral elsewhere |
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.
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.
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.
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.
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.
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.
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 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.
github.com/isacomp-project/isacomp (April 2026 clone); isacomp-guru SKILL.md and reference files; isacomp-cowork plugin README.Made in Glasgow · Designed for Santa Barbara · Read everywhere