> For the complete documentation index, see [llms.txt](https://docs.loci-dev.net/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.loci-dev.net/loci-release-notes/loci-plugin-for-ai-coding-assistants-release-notes/loci-v0.1-date-02-jul-2026.md).

# LOCI v0.1 (Date: 02 Jul 2026)

Coding agents write code. LOCI thinks ahead: it predicts what AI-generated code will do — time, power, memory, and system behavior — during planning and code writing, before any of it runs. Now directly inside Claude Code, at exactly those two moments: Plan Guard while Claude drafts a plan, Save Guard the instant it writes.

## New

Two stations run automatically, the moment Claude plans or writes:

* **Plan Guard (`loci-preflight`)** — Before Claude writes a line of code, LOCI audits the plan at the binary level — timing, power, and control-flow impact of the functions involved — and returns a verdict: `GOOD`, `ADJUST PLAN`, or `STOP`.
* **Save Guard (`loci-post-edit`)** — Every source edit is compiled and diffed against the pre-edit binary automatically. LOCI returns a per-function regression verdict — `OK`, `CAUTION`, or `FLAG` — and proposes a fix when it flags one.

Five more are yours to call on directly, in plain language:

* **`exec-trace`** — Ask *"What's the execution cost of `main()`?"* and get function-level timing and power, grounded in real workloads and platform traces, with a confidence band on every number.
* **`stack-depth`** — Ask *"Is my stack safe for `TaskMain`?"* and get worst-case stack depth along the deepest call path, checked against your budget, with RTOS task entry points detected automatically (`xTaskCreate`, `Task_construct`, `osThreadNew`, `FreeRTOSConfig.h`).
* **`memory-report`** — Ask *"How much ROM/RAM does my build use?"* and get a section-by-section breakdown of the compiled binary and its top consumers.
* **`control-flow`** — Ask *"Show me the call graph for `process_data()`."* and get an annotated control-flow graph — every branch, every call edge — with indirect-call hazards flagged by name.
* **`trends`** — Ask *"How are my functions doing?"* and get per-function timing, power, stack, and memory history on the current branch, broken down by improved, regressed, and baseline.

Plus three that keep the other five running smoothly:

* **`/help`** — Shows your environment status, sign-in state, and the full skill list, with a contextual next step.
* **`/loci:setup`** — Reinstalls and repairs the `loci` CLI. Idempotent — safe to run any time something looks off.
* **`/bug-report`** — Generates a full diagnostic report when a skill doesn't fire the way you expect.

And the record of all of it:

* **LOCI Portal** — Every run from Claude Code is logged automatically, with a Sessions log, configurable gate thresholds, and PR-level review against your open pull requests.
* **Session hooks** — `SessionStart` detects your project and build environment automatically; `PreToolUse` snapshots the binary ahead of every edit so Save Guard has a baseline to diff against.

## Good to know

* Every result comes from the compiled binary directly — no profilers, no runtime instrumentation, no connected board, and no source code changes.
* The gate is advisory, not automatic: LOCI proposes a verdict, a human makes the final call.
* `stack-depth`, `memory-report`, and `control-flow` run entirely from the local binary — no MCP connection or network dependency required.

## Prerequisites

| Requirement                                | Version | Needed for                                              |
| ------------------------------------------ | ------- | ------------------------------------------------------- |
| Claude Code                                | Latest  | Everything                                              |
| Python                                     | 3.12+   | The `loci` CLI (local ELF/build analysis)               |
| uv                                         | Any     | Installing the `loci` CLI                               |
| jq                                         | Any     | Session hooks                                           |
| Compiled binaries (`.elf` / `.o` / `.axf`) | —       | All skills                                              |
| Network access to the LOCI backend         | —       | Plan Guard, Save Guard, on-demand timing/power analysis |

One cross-compiler, matched to the target: `arm-none-eabi-gcc` (ARM Cortex-M), `aarch64-linux-gnu-gcc` (ARM Cortex-A), `tricore-elf-gcc` (TriCore), `tiarmclang` or `armcl` (TI ARM), `g++` or `clang++` (x86/x64). `stack-depth`, `memory-report`, and `control-flow` run without a cross-compiler or MCP connection at all.

***

LOCI works alongside Claude Cod. This is our first release for Claude Code specifically — more AI Agents Cursor, Copilot, and your own agents; deeper CI/CD integration; and broader toolchain coverage are next.

Questions or feedback? <loci@auroralabs.com>