openapi-snapshot 0.1.4

Fetch OpenAPI JSON from a running server. Lightweight MCP alternative for AI agents (Claude Code, Cursor, etc.).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

# openapi-snapshot promo

## Origin story

Coding agents kept hallucinating what my backend returned. They'd guess response shapes, make up fields, and my frontend code would break. So I built a CLI that snapshots the actual OpenAPI spec to a file. Now the agent reads the real contract instead of guessing.

---

## Tweet

```
Coding agents kept hallucinating my API responses.

Built a CLI that snapshots your backend's OpenAPI spec to a file. Now Claude/Cursor reads the real contract instead of guessing.

cargo install openapi-snapshot

https://github.com/0xashrk/openapi-snapshot
```

Alt (MCP angle):
```
If you're using Claude Code with a local backend, you don't need MCP.

openapi-snapshot keeps your API spec synced to files. Agent reads spec, curls endpoints. Done.

cargo install openapi-snapshot
```

Alt (shortest):
```
Your coding agent is hallucinating your API responses.

Fix: cargo install openapi-snapshot
```

---

## Blog post (dev.to / hashnode / personal)

**Title:** You don't need MCP for local dev — just good docs

**Body:**

I've been using Claude Code with a Rust backend and kept wondering if I should set up an MCP server for it. Then I realized: Claude can already read files and run curl. Why add a protocol layer?

So I built `openapi-snapshot` — a CLI that fetches your backend's OpenAPI JSON and writes it to a file. That's it.

### The workflow

1. Your backend exposes OpenAPI (via utoipa, swagger, whatever)
2. Run `openapi-snapshot --out openapi/backend.json`
3. Reference it in your `CLAUDE.md`:
   ```
   Backend endpoints: openapi/backend.json
   ```
4. Claude reads the spec, discovers your endpoints, calls them via curl

No MCP server. No new protocol. Just HTTP and files.

### When MCP still makes sense

- You're using Claude web UI (can't run curl)
- You need complex auth/state management
- You're building for non-technical users

For local dev with Claude Code or Cursor? This is simpler.

### Install

```
cargo install openapi-snapshot
```

GitHub: https://github.com/0xashrk/openapi-snapshot

---

## Where to post

### Reddit
- r/rust — "Show HN"-style post, Rust crowd appreciates small focused tools
- r/ClaudeAI — directly relevant audience
- r/LocalLLaMA — tangentially relevant (local AI tooling)
- r/cursor — if they allow tool posts

### GitHub Discussions
- [Claude Code issues/discussions](https://github.com/anthropics/claude-code) — share as a workflow tip
- [Cursor community](https://forum.cursor.com/) — similar use case

### Other
- Hacker News (Show HN) — hit or miss but Rust + AI tooling could land
- Twitter/X — tag @AnthropicAI, @cursor_ai, Rust community folks
- Dev.to / Hashnode — blog post for longer-form SEO

### Awesome lists (not MCP-specific)
- [awesome-rust](https://github.com/rust-unofficial/awesome-rust) — under "Development tools" or "Web" maybe
- [awesome-cli-apps](https://github.com/agarrharr/awesome-cli-apps) — if they have a dev tools section

---

## One-liner pitches

**For Rust folks:**
> CLI that snapshots OpenAPI JSON from a running server. Keeps agents and frontend tooling synced with your backend contract.

**For AI tooling folks:**
> Lightweight MCP alternative — Claude Code reads the spec file, curls your API directly. No protocol server needed.

**For "why should I care":**
> Stop explaining your API endpoints to Claude every session. Snapshot them once, reference in CLAUDE.md, done.