Skip to content
Back to search

distributed-system-testing

AI-agent skills for distributed-systems testing

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/shenli--distributed-system-testing/badge.svg)](/listings/shenli--distributed-system-testing)

HTML

<a href="/listings/shenli--distributed-system-testing"><img src="/api/listings/shenli--distributed-system-testing/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Paste this at any AI coding agent (Claude Code, Codex, Copilot CLI, Cursor, Gemini, or anything else that reads Markdown and runs shell):

Read https://raw.githubusercontent.com/shenli/distributed-system-testing/main/INSTALL.md
and follow the instructions to install and configure
distributed-testing-skills for this agent.

The agent fetches [`INSTALL.md`](INSTALL.md), clones the repo to `~/.local/share/distributed-testing-skills/`, and wires the skills in (symlinks under `~/.claude/skills/` for Claude Code, a pointer block in `~/AGENTS.md` for other agents).

After that, ask any agent on the machine to "design a test plan for this system" or "execute the plan at X" and it'll follow the SKILL.md workflow.

Update

**Paste the same one-liner again.** `INSTALL.md` is idempotent: if the install path exists, it does `git pull --ff-only`; if not, it does `git clone`. Symlinks always point at the cloned content so they pick up the new version automatically. The `~/AGENTS.md` pointer block uses HTML markers and is replaced cleanly on each run — no duplication.

If you have local edits to the cloned skills, `git pull --ff-only` will fail; the agent will stop and ask before discarding them.

Manual install (if you'd rather see what's happening)

git clone https://github.com/shenli/distributed-system-testing.git \
    ~/.local/share/distributed-testing-skills

# Claude Code: symlink under ~/.claude/skills/
mkdir -p ~/.claude/skills
ln -snf ~/.local/share/distributed-testing-skills/skills/designing-distributed-system-tests \
    ~/.claude/skills/designing-distributed-system-tests
ln -snf ~/.local/share/distributed-testing-skills/skills/executing-distributed-system-tests \
    ~/.claude/skills/executing-distributed-system-tests

# Codex / Copilot CLI / Cursor / Gemini / others: see INSTALL.md

As a Claude Code plugin (alternative)

The repo carries a plugin manifest and a marketplace manifest under `.claude-plugin/`, so Claude Code can install it as a plugin instead of symlinking:

/plugin marketplace add shenli/distributed-system-testing
/plugin install distributed-testing-skills@distributed-testing-skills

Both skills are auto-discovered from `skills/`. The one-line `INSTALL.md` flow above stays the agent-agnostic path (Codex, Copilot CLI, Cursor, Gemini).

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 13 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "distributed-testing-skills",
  3. "owner": {
  4. "name": "Li Shen"
  5. },
  6. "plugins": [
  7. {
  8. "name": "distributed-testing-skills",
  9. "source": "./",
  10. "description": "Two coupled skills that design and execute claim-driven, Jepsen-style test plans for distributed and stateful systems."
  11. }
  12. ]
  13. }
README.md · README · 446 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # Distributed Systems Testing Skills
  2. Two skills that help an AI coding agent **design meaningful tests, run them,
  3. and explain the results** for systems that store data or run across multiple
  4. processes or machines.
  5. Start with a product promise—such as “once saving succeeds, the data is still
  6. there after a restart”—and turn it into tests your agent can run and check.
  7. Use these skills for databases, queues, workflow engines, and services where
  8. retries, simultaneous requests, or failures could lose or duplicate data.
  9. A service running on one machine can benefit too.
  10. You do not need to be a testing expert. Describe the feature and what should
  11. remain true; the design skill helps choose the tests and explain why they matter.
  12. The skills are Markdown instructions, templates, and reference material.
  13. Your coding agent follows them using your project's test tools and runtime.
  14. This repository does not bundle a database test runner or a ready-made cluster.
  15. | Skill | Give it | It produces |
  16. |---|---|---|
  17. | [Design tests](skills/designing-distributed-system-tests/SKILL.md) | A codebase and the change or feature you want to test | A plan explaining what to test, how to check it, and how much testing to do |
  18. | [Execute tests](skills/executing-distributed-system-tests/SKILL.md) | A plan and a test environment | Results, supporting logs and data, steps to reproduce failures, and a report |
  19. You can use the design skill on its own. Execution is a separate step that
  20. reads the saved plan, so you can review the work and its cost before running it.
  21. Start with the [quick start](#quick-start), [Codex setup](#for-codex-users),
  22. or [test environment guide](#choose-and-prepare-a-test-environment).
  23. ## Quick start
  24. ### 1. Install the skills
  25. Paste this into your coding agent:
  26. ```text
  27. Read https://raw.githubusercontent.com/shenli/distributed-system-testing/main/INSTALL.md
  28. and follow the instructions to install or update
  29. distributed-testing-skills for this agent.
  30. ```
  31. The [installation guide](INSTALL.md) uses a shared checkout at
  32. `~/.local/share/distributed-testing-skills/` and configures pointers or
  33. symlinks for your agent. Reuse the same prompt to update. The explicit paths
  34. in the prompts below also let you load a skill without automatic discovery.
  35. Substitute your install path if you chose a different location.
  36. For Claude Code, the repository also includes a plugin installation option:
  37. ```text
  38. /plugin marketplace add shenli/distributed-system-testing
  39. /plugin install distributed-testing-skills@distributed-testing-skills
  40. ```
  41. ### 2. Design a plan in your project's directory
  42. Start your agent in the repository you want to test. For a specific change:
  43. ```text
  44. Use ~/.local/share/distributed-testing-skills/skills/designing-distributed-system-tests/SKILL.md
  45. Design a test plan for the current branch's changes to adding log entries,
  46. retrying failed requests, and recovering after a crash.
  47. Reuse the existing tests and setup instructions.
  48. Save the plan to docs/testing-plans/append-recovery.md.
  49. ```
  50. Replace the example feature with yours. For a broader review, ask for a
  51. **project-wide plan** and name the parts to include. That mode reviews existing
  52. tests and identifies missing coverage across the system rather than one change.
  53. Review the promises being checked, proposed tests, required tools, and run times.
  54. A documentation typo or similarly low-impact change should get a lightweight
  55. testing recommendation instead of a distributed test plan.
  56. ### 3. Run the plan against a disposable test environment
  57. ```text
  58. Use ~/.local/share/distributed-testing-skills/skills/executing-distributed-system-tests/SKILL.md
  59. Run the small initial checks (the smoke tier) from
  60. docs/testing-plans/append-recovery.md against this project's local test
  61. environment. Keep temporary test scripts and results under
  62. ./test-sessions/. Use default mode; do not modify project source files.
  63. Report what ran, what failed, and what remains untested.
  64. ```
  65. The execution skill discovers existing tools, asks what is available in your
  66. environment, then verifies the requirements. Missing dependencies or ineffective
  67. simulated failures must be reported rather than silently counted as successful
  68. tests. Start small, then request the longer, more thorough runs defined in the plan.
  69. See [USAGE.md](USAGE.md) for detailed prompts, custom output paths, and author mode.
  70. ## For Codex users
  71. Run the installation prompt above in Codex. The guide links both skill folders
  72. from the shared checkout into `~/.agents/skills/`, where Codex discovers them.
  73. For a project-only installation, use that project's `.agents/skills/` instead.
  74. These locations and symlink support are described in the
  75. [official Codex skills documentation](https://developers.openai.com/codex/skills).
  76. Open the project you want to test. In Codex CLI or the IDE extension, use
  77. `/skills` to check that both skills appear, or type `$` to select one. If a newly
  78. installed skill does not appear, restart Codex. You can also use the explicit
  79. file-path prompts in the quick start. See the
  80. [official invocation guidance](https://developers.openai.com/codex/skills#how-codex-uses-skills).
  81. For example, ask Codex to design a plan:
  82. ```text
  83. $designing-distributed-system-tests
  84. Design a test plan for this project's retry and recovery behavior.
  85. I have Docker locally and can run disposable containers.
  86. Start with normal operation, then simultaneous requests and restarts.
  87. Save the plan to docs/testing-plans/retry-recovery.md.
  88. ```
  89. After reviewing it, run the initial tests:
  90. ```text
  91. $executing-distributed-system-tests
  92. Run the smoke tier of docs/testing-plans/retry-recovery.md.
  93. Use default mode and save results under ./test-sessions/.
  94. Docker is available; use the project's documented container setup.
  95. Report any missing tools or permissions and which tests they prevent.
  96. ```
  97. Installing a skill supplies instructions, not Docker, remote access, or a test
  98. cluster. Codex must be able to reach the environment where commands will run.
  99. For remote testing, give it the test hosts, your existing connection method,
  100. and the project's setup commands. If access is unavailable, it can still
  101. design the plan, but cannot report that remote tests ran.
  102. ## Choose and prepare a test environment
  103. Use the smallest setup that can answer your question. These are starting
  104. points to adapt to your application, not hardware requirements or bundled
  105. deployment recipes.
  106. | Goal | Suggested setup | What it can tell you |
  107. |---|---|---|
  108. | Find correctness bugs quickly | Your laptop, the project's runtime, and disposable local processes or containers | Whether requests, retries, transactions, and restarts behave correctly in that setup |
  109. | Compare performance between versions | A quiet, dedicated test machine; a separate machine to send requests when measuring a service | Whether a change affects speed or resource use under the same conditions |
  110. | Test failures across machines | Separate test hosts or VMs, one server instance per host, plus a separate test controller | How the system handles one server stopping or communication between servers breaking |
  111. ### Local correctness tests
  112. Start with the project's existing setup instructions. Install its required
  113. language/runtime and, if it uses containers, Docker or another supported
  114. container runtime. Give each instance its own ports and data directory or
  115. volume. Use a dedicated test database and a repeatable way to reset its data.
  116. For containers that communicate by name, a user-defined Docker network can
  117. provide name resolution between them. See [Docker networking](https://docs.docker.com/engine/network/).
  118. Several containers on one laptop are useful for exercising communication, but
  119. still share the host's resources and failure risks. They do not establish
  120. resilience to losing a separate machine.
  121. ### Performance tests
  122. A **load generator** is the program sending test requests. Prefer the project's
  123. existing benchmark; for example, PostgreSQL's
  124. [pgbench](https://www.postgresql.org/docs/current/pgbench.html) supports repeated
  125. transactions and custom SQL scripts. Choose requests and data sizes that resemble
  126. your application, rather than treating a tool's default workload as representative.
  127. 1. **Make comparisons fair.** Use the same hardware, data, settings, and test
  128. script for the old and new versions. Avoid unrelated builds or heavy jobs
  129. on the test machines. Record CPU, memory, disk, software versions, and settings.
  130. 2. **Separate startup from measurement.** Give caches and connections time to
  131. warm up, then measure a fixed window. Test cold starts separately if they
  132. matter. Repeat each version's run several times and report the variation.
  133. 3. **Increase traffic gradually.** Record requests attempted and completed per
  134. second, errors, and timeouts. Monitor the load generator too: if it is at
  135. capacity, the test may be measuring the client rather than the service.
  136. 4. **Look beyond averages.** Report p50, p95, and p99 response times—the times
  137. within which 50%, 95%, and 99% of requests finish. Capture CPU, memory,
  138. network, and disk use alongside them, and keep data-correctness checks active.
  139. 5. **Match how traffic arrives.** If production requests keep arriving while
  140. the service slows down, use a generator that can maintain that arrival rate.
  141. Waiting for each response before sending more can hide overload. The
  142. [k6 traffic-model guide](https://grafana.com/docs/k6/latest/using-k6/scenarios/concepts/open-vs-closed/)
  143. explains the distinction. Report missed request starts as well as completed ones.
  144. Tell the design skill your target request rate, data size, acceptable response
  145. time, and available machines. If you do not have targets yet, ask for an initial
  146. measurement plan; do not invent a pass threshold from the same run being judged.
  147. ### A real distributed setup
  148. Use the application's supported cluster size. For a service that supports three
  149. voting replicas, a starting layout is three server hosts plus a controller that
  150. sends requests and collects results. A three-node majority needs two votes, so
  151. this layout can exercise loss of one voter; other architectures need different
  152. layouts. Separate VMs on one physical host still do not test physical-host loss.
  153. Before running tests:
  154. - Record each host's address, role, software version, and storage location.
  155. Match production storage behavior where it matters; do not give replicas the
  156. same data directory unless shared storage is part of the actual design.
  157. - Verify client-to-server and server-to-server connections. If the design uses
  158. a leader, verify who it is and that replication works before causing failures.
  159. - Arrange remote start/stop commands and log collection. Keep the controller's
  160. management connection available while interrupting application traffic, so
  161. the test can restore communication and collect evidence.
  162. - Choose how to stop one process or interrupt one specific network link, and
  163. check the required permissions. Use the project's existing tools first.
  164. Restore each interruption and verify recovery before the next test.
  165. - Keep clocks synchronized for comparing logs, but do not assume timestamps on
  166. different hosts establish an exact event order. Use the recording method
  167. required by the plan's checker.
  168. Start with normal traffic, then one server restart, then a broken connection
  169. while requests continue. Test both successful recovery and the correctness of
  170. the data. Larger clusters, cross-region layouts, and storage failures should
  171. follow the guarantees you actually need to test.
  172. Give Codex a concrete environment description, for example:
  173. ```text
  174. $designing-distributed-system-tests
  175. Design a plan for this project's three-replica test cluster.
  176. Available: Linux test hosts test-a, test-b, test-c, plus test-controller.
  177. The controller has SSH access and can reach the application ports.
  178. Use our existing setup and reset commands in docs/testing.md.
  179. Cover normal operation, one server restart, and one interrupted network link.
  180. Record how each failure is verified and how the environment is restored.
  181. Save the plan to docs/testing-plans/three-replica-recovery.md.
  182. ```
  183. Replace those example hosts and file path with your own. For performance work,
  184. use the same pattern with your benchmark command, machine details, workload,
  185. and performance targets. Keep commands, versions, results, and reset instructions
  186. together so another developer can repeat the run.
  187. ## How it works
  188. The workflow connects a product promise to an observable result:
  189. 1. **Find the promises.** Inspect documentation, code, configuration, and
  190. existing tests. Identify what the system promises, under which settings,
  191. and where the guarantee is ambiguous. Record actual builds and effective
  192. settings rather than assuming a mode name proves its behavior.
  193. 2. **Identify ways it could fail.** For example, a retry might repeat an
  194. operation the server already completed, or a restart might lose data that
  195. was reported as saved. Test normal operation first, then simultaneous
  196. requests and failures where relevant.
  197. 3. **Define the tests.** Specify which requests to send, how long to run,
  198. and exactly what makes a result correct. “The server stayed up” is not
  199. enough to establish that it kept every saved entry.
  200. 4. **Run and record.** Reuse the project's tools, create temporary test
  201. scripts where needed, and record requests and responses. When deliberately
  202. interrupting a connection or stopping a process, verify that it happened.
  203. 5. **Check and explain.** Evaluate the recorded results. When a test fails,
  204. try to find a smaller example that reproduces the problem. Investigate
  205. whether the bug is in the application, the test code, or the environment,
  206. and explain which planned tests remain incomplete.
  207. For tests involving simultaneous requests, the order of events can matter as
  208. much as the final data. The agent records what each client attempted, when it
  209. happened, and what came back. A timeout is an unknown outcome: the server may
  210. have completed the request even though the client never received its response.
  211. ### Terms you may see in the detailed guides
  212. | Term | Plain-language meaning |
  213. |---|---|
  214. | SUT (system under test) | Your application, service, or database being tested |
  215. | Claim | A promise the system makes, such as keeping data after a restart |
  216. | Scenario | One test setup: the requests to send, conditions to create, and results to check |
  217. | Checker or oracle | Code that decides whether the observed results are correct |
  218. | Test harness | The scripts and supporting code that set up and run a test |
  219. | Operation history | A record of requests, responses, and their timing |
  220. | Fault injection; nemesis | Deliberately causing a failure; the tool that causes it |
  221. | Budget | How much testing to do: run time, number of requests, repetitions, and configurations |
  222. | Verdict | The recorded result: passed, failed, incomplete, or not run |
  223. ### Example: retrying a request must not add the same entry twice
  224. Suppose your service adds entries to a log and never removes them. Each request
  225. includes an **idempotency key**: an identifier reused when retrying that same
  226. request, so the server can recognize it. The service promises:
  227. - Retrying the same request with the same key never creates a second entry.
  228. - Once the server reports success, the entry is still there after a restart.
  229. A focused plan could include these scenarios:
  230. | Scenario | What it tries to expose | Evidence and check |
  231. |---|---|---|
  232. | Send the same request from two clients at once | Both callers create an entry | Give both requests the same key and check that no more than one entry was created |
  233. | Interrupt a response, then retry | The client repeats a request the server already completed | Record the interruption and retry; check for duplicates without assuming the first request failed |
  234. | Restart after successful requests | Saved entries disappear | Record which requests succeeded and check that their entries remain after restart |
  235. The real plan also specifies test files, request counts, run times, cleanup,
  236. and the data needed to check the results. Surviving a power outage needs a
  237. separate test: stopping a process can leave data in operating-system memory
  238. that would disappear if the machine lost power.
  239. A successful health check after restart tells you the service responds. It does not
  240. establish either of the two guarantees above; the recorded operations and
  241. state checks do that work.
  242. ## What gets tested
  243. You can describe the behavior you care about without choosing a testing tool.
  244. The agent selects an approach based on your code and existing tests. Advanced
  245. tools such as Jepsen, a framework for testing systems under failures, are
  246. optional; a small test using your existing tools may be enough.
  247. | Concern | Approach and reference |
  248. |---|---|
  249. | Unusual inputs or sequences of operations produce wrong results | [Generate many inputs and check expected relationships](skills/designing-distributed-system-tests/references/property-and-metamorphic.md) |
  250. | SQL queries or transactions return incorrect data | [Compare with a reference database and check each transaction's operations](skills/designing-distributed-system-tests/references/sql-semantic-testing.md) |
  251. | Simultaneous requests lose updates or return inconsistent data | [Check request histories against the promised behavior](skills/designing-distributed-system-tests/references/jepsen-and-elle.md) |
  252. | A bug appears only with particular timing or inputs | [Replay controlled event schedules](skills/designing-distributed-system-tests/references/deterministic-simulation.md) or [generate varied inputs](skills/designing-distributed-system-tests/references/fuzzing.md) |
  253. | A connection breaks or one part of the system stops responding | [Deliberately interrupt connections and processes](skills/designing-distributed-system-tests/references/chaos-and-fault-injection.md) |
  254. | A crash or upgrade loses or corrupts data | [Check recovery, saved data, and upgrades](skills/designing-distributed-system-tests/references/crash-recovery-and-upgrade.md) |
  255. | One customer's data or heavy traffic affects another customer | [Check access boundaries](skills/designing-distributed-system-tests/references/boundary-and-isolation-testing.md) and [performance per customer](skills/designing-distributed-system-tests/references/performance-and-benchmarking.md) |
  256. | A coordination protocol may have a design error | [Model the design and check its rules](skills/designing-distributed-system-tests/references/formal-methods-tla.md) |
  257. The [catalog index](skills/designing-distributed-system-tests/references/catalog-index.md)
  258. helps choose techniques. The [pitfall catalog](skills/designing-distributed-system-tests/references/common-distributed-systems-pitfalls.md)
  259. provides examples of recurring bugs to consider when planning tests.
  260. For example, SQL comparisons must preserve duplicate rows and data types;
  261. otherwise the test could hide incorrect results. Storage tests must actually
  262. reach the disk-writing and recovery code they claim to test, rather than
  263. exercising only data held in memory.
  264. ## Outputs and how to read them
  265. By default, a design-and-execute run produces:
  266. ```text
  267. docs/testing-plans/<slug>.md
  268. test-sessions/<slug>/<UTC_timestamp>/
  269. ├── session-log.md # tools, versions, settings, timeline, amount of testing
  270. ├── logs/ # application and test-script logs
  271. ├── metrics/ # measurements collected during the run
  272. ├── artifacts/ # request records, temporary scripts, data, failure examples
  273. └── findings/
  274. ├── <scenario>.md # findings recorded as scenarios finish
  275. └── report.md # results, evidence, and what remains untested
  276. ```
  277. **Read the plan before running tests.** It explains what could go wrong, which
  278. tests will look for those problems, and what tools they need. It defines three
  279. levels of testing:
  280. - **Smoke:** a small initial run to check basic behavior and test setup.
  281. - **Hardening:** more thorough testing, using longer runs, more inputs,
  282. repeated runs, or additional settings as appropriate.
  283. - **Release:** the testing proposed before shipping. If this has not been
  284. defined, the plan must say why and when to revisit it.
  285. Each level has a budget specifying how much testing to do. This lets you review
  286. the time and resources needed before asking the agent to run it.
  287. **Read the report after running tests.** It links results to logs and recorded
  288. data and explains what remains untested. The result labels mean:
  289. | Verdict | Meaning |
  290. |---|---|
  291. | `PASS-smoke` | The small initial run completed all required checks without finding a problem |
  292. | `PASS-hardening` | The more thorough run completed its required checks without finding a problem; any planned failures were verified to have happened |
  293. | `FAIL-reproducible` / `FAIL-nondeterministic` | A problem was found; rerunning either reproduced it or did not |
  294. | `INCONCLUSIVE-env` | A required tool or environment capability was unavailable |
  295. | `INCONCLUSIVE-oracle-too-weak` | The checks, recorded data, or amount of testing were insufficient to decide |
  296. | `INCONCLUSIVE-fault-not-proven` | The test could not verify that the intended interruption or failure happened |
  297. | `PARTIAL-surface` / `PARTIAL-model` | Only basic checks ran, or only some of the required behavior was checked |
  298. | `NOT-RUN` | A planned scenario was not attempted |
  299. Thorough testing of normal operation can earn `PASS-hardening` without causing
  300. failures. That does not establish how the system behaves during failures.
  301. Likewise, one quick restart test does not count as a thorough run.
  302. See the [verdict rules](skills/executing-distributed-system-tests/references/verdict-taxonomy.md)
  303. for how labels are assigned when several conditions apply.
  304. A passing run means no problem was found in the behavior tested. It is not
  305. a proof of correctness or an automatic release approval. Review the report's
  306. untested areas and evidence before deciding whether to ship. “The vendor says
  307. it is fixed” is kept separate from “we reran the failing test and checked the fix.”
  308. ## What the agent may change
  309. In **default execution mode**, the skill leaves project source files alone.
  310. It can create temporary test scripts and result files under the session
  311. directory and operate the test environment. Tests can restart processes,
  312. interrupt traffic, or change test data, so use an environment you can reset.
  313. In **author mode**, explicitly requested by you, it adds tests to your project
  314. so you can rerun them to catch the same bugs later. It uses the file paths and
  315. starter code specified in the plan, completes and runs the tests, then stages
  316. them for review without committing. If a target file already exists, it asks
  317. whether to overwrite it, skip it, or write a separate file.
  318. The design skill writes a plan, not a full test implementation. A useful plan
  319. may identify missing test tools or setup that need engineering work before
  320. the tests can run.
  321. ## Repository guide
  322. - [INSTALL.md](INSTALL.md): installation and updates.
  323. - [USAGE.md](USAGE.md): prompts for each workflow and mode.
  324. - [Design skill](skills/designing-distributed-system-tests/SKILL.md) and
  325. [plan template](skills/designing-distributed-system-tests/assets/plan-template.md):
  326. the planning workflow and its output structure.
  327. - [Execution skill](skills/executing-distributed-system-tests/SKILL.md) and
  328. [findings template](skills/executing-distributed-system-tests/assets/findings-report-template.md):
  329. the execution workflow and its output structure.
  330. - [Result-checking approaches](skills/executing-distributed-system-tests/references/oracle-patterns.md)
  331. and [request-recording guidance](skills/designing-distributed-system-tests/references/history-discipline.md):
  332. choosing a checker and recording the data it needs.
  333. - [evals/](evals/README.md): manual regression prompts for changes to the skills.
  334. - [specs/](specs/): historical design notes; the current skill files define the workflow.
  335. ## Status and limitations
  336. These skills are evolving. Development has included local tests against
  337. AgentDB and LMCache. Those machine-specific plans and results live under
  338. `verification/`, which is gitignored and is not included in this repository.
  339. The evaluation prompts are **manual cases, not an automated test suite**.
  340. Some need other projects checked out locally; others are self-contained design or result
  341. reviews. They test the agent's use of the skills, separately from the tests
  342. that the skills help you run against your own system.
  343. Results depend on what was tested and how the agent built and checked the tests.
  344. The report must show supporting evidence and what was left untested so you
  345. can judge how much to rely on it.
  346. ## Acknowledgements
  347. The technique catalog draws on Andrey Satarin's
  348. [testing-distributed-systems](https://github.com/asatarin/testing-distributed-systems)
  349. catalog and research on Jepsen/Elle, fault injection, crash consistency,
  350. deterministic simulation, and formal methods. Individual references link to
  351. the original tools and papers.
  352. ## License
  353. [MIT](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.