REACH + OCTO

Appearance

What is REACH? ​

REACH — Runtime Executable Adaptive C# Handler.

A local workflow practice where you declare what you want to reach into, and Claude compiles it to typed C# that runs against your live systems. No pre-built connectors. No fixed implementations. The capability surface is unlimited because Claude picks the right NuGet library for each task, not you.

The Idea in One Paragraph ​

You have intent. You know what system you want to reach into and what you want to find there. What you don't want to do is spend time choosing the right library, writing COM Interop boilerplate, handling connection strings, or parsing output formats. That's implementation. REACH separates the intent from the implementation: you write the .reach file, Claude compiles it to typed C#, runs it, reads what came back, and continues the conversation with findings.

How It Works ​

dotnet run task.cs

Each reach is a single .cs file. Dependencies declared inline — no .csproj, no scaffolding:

csharp
#:package [email protected]

using Outlook = Microsoft.Office.Interop.Outlook;

var app = new Outlook.Application();
var inbox = app.ActiveExplorer().Session.GetDefaultFolder(
    Outlook.OlDefaultFolders.olFolderInbox);
// ...

Claude writes the file, runs it, reads stdout/stderr, fixes compile errors, reruns. You see the findings — not the plumbing.

Two Modes, One Structural Gate ​

Every arm declares its mode in its own header — MODE: READ or MODE: ACT — and the runtime enforces it, not just documents it:

READ  →  reach into sources, return findings
          no side effects, runs immediately

ACT   →  change state — launch, draft, post, write
          does not run without an explicit confirmation first —
          structurally, not as a policy someone has to remember

An ACT arm — or one with no declared mode at all, which defaults to the safer assumption — doesn't execute on the first call. It surfaces what it's about to do and waits. A second, explicit call confirms it, and only then does it actually run. write_arm won't even save an arm with no declared mode in the first place. Reads run without asking. Writes always stop first — not because the runtime happens to check, but because it structurally can't proceed without that second call.

The Iteration Loop ​

Claude follows this loop for every reach:

1. Understand intent from the .reach file or conversation
2. Write task.cs with appropriate #:package directives
3. dotnet run task.cs
4. Read stdout / stderr
5. Compile error  → fix types, rerun
6. Runtime error  → adjust logic, rerun
7. Wrong output   → reason about it, adjust, rerun
8. Return findings or continue conversation

Compile errors are features. They surface immediately and are typed. Claude fixes them faster than debugging silent script failures.

The Artifact ​

Every meaningful reach writes a .reach-artifact — the typed, human-readable, git-diffable record of what was found.

REACH      sprint-cadence-review
ID         proj.2026.sprint-10
DATE       2026-06-11
─────────────────────────────────────────
period:    2026-04-01 to 2026-06-11
rpm:       all-red
after-hours: 30%
target:    10-15%

finding: |
  Sustained redline across all 10 weeks.
  30% after-hours structural, not occasional.

recommendation:
  recovery: open-valley-week

Plain text. No server. No database. Lives in your project. Git tracked. Claude reads it next sprint without re-running everything.

What Claude Never Shows You ​

Working in REACH, you never see:

  • NuGet package names (Claude chooses them)
  • COM Interop calls and casting
  • Playwright startup and teardown
  • SqlClient connection boilerplate
  • WinForms plumbing for prompt dialogs

You see intent. You see findings. You see the right pause at the right moment.

Named Reaches — The Sharing Unit ​

A .reach file defines a reusable pattern:

# sprint-review.reach

name        sprint-cadence-review
description Read sprint health across email, calendar, and commits

reach outlook.inbox + outlook.calendar + git.commits
  since     10-weeks-ago
  analyze   rpm
  benchmark after-hours 15%
  output    report

Share it. Fork it. Someone else changes the project name and runs it. That's the adoption path — a file, not a framework.

Next ​