Skip to content
Back to search

prempti-skills

MarketplaceWorks with Claude CodeGitHub

Falco-powered policy and visibility layer for AI coding agents

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/falcosecurity--prempti/badge.svg)](/listings/falcosecurity--prempti)

HTML

<a href="/listings/falcosecurity--prempti"><img src="/api/listings/falcosecurity--prempti/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

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

> [!IMPORTANT] > **Migrating from `coding-agents-kit`?** Prempti does not migrate or remove existing `coding-agents-kit` installations. Uninstall `coding-agents-kit` first to avoid duplicate services or stale Claude Code hooks.

macOS

Download the universal `.pkg` installer from the [latest release](https://github.com/falcosecurity/prempti/releases/latest) and open it:

open prempti-<version>-darwin-universal.pkg

The macOS Installer wizard guides you through the setup. The service starts immediately and on every subsequent login.

To install non-interactively (CI, scripted setup, SSH session):

installer -pkg prempti-<version>-darwin-universal.pkg \
          -target CurrentUserHomeDirectory

> [!NOTE] > Since the binaries are not code-signed, macOS Gatekeeper may block them on first run. > Go to **System Settings > Privacy & Security** and allow the blocked binary, or clear the quarantine attribute from the whole install tree (executables in `bin/` and the plugin library in `share/` can both be flagged): > ```bash > xattr -dr com.apple.quarantine ~/.prempti > ```

Linux

Download the package for your architecture from the [latest release](https://github.com/falcosecurity/prempti/releases/latest):

tar xzf prempti-<version>-linux-x86_64.tar.gz
cd prempti-<version>-linux-x86_64
bash install.sh

The installer copies all components to `~/.prempti/`, starts a systemd user service, and registers the hook automatically.

Windows

From the [latest release](https://github.com/falcosecurity/prempti/releases/latest), download the `.msi` for your CPU architecture and double-click it (or run `msiexec /i prempti-<version>-windows-<arch>.msi`).

The MSI deploys all components to `%LOCALAPPDATA%\prempti\`, adds `bin\` to your user `PATH`, registers the Claude Code hook, registers an auto-start entry for subsequent logins, and starts the service immediately so Claude Code is protected without any extra step.

> [!NOTE] > Pick the MSI that matches your CPU: `prempti-<version>-windows-x64.msi` on Intel/AMD64, `prempti-<version>-windows-arm64.msi` on Windows ARM64. The x64 MSI can install under emulation on ARM64 hosts but prefer the native ARM64 MSI for best performance. See [`installers/windows/`](installers/windows/) for build prerequisites and details.

Verify

**Linux / macOS**

~/.prempti/bin/premptictl status
~/.prempti/bin/premptictl hook status
~/.prempti/bin/premptictl health

> **Tip:** Add `export PATH="$HOME/.prempti/bin:$PATH"` to your shell profile to use `premptictl` without the full path.

**Windows**

The installer starts the service automatically. Open a **new** terminal (so the updated `PATH` is picked up) and verify:

premptictl status
premptictl hook status
premptictl health

Expected `health` output: `OK: pipeline healthy (synthetic event → allow)`.

If the service is not running (rare — e.g. the post-install timed out), start it manually with `premptictl start`. Auto-start on every login is already registered.

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 · 22 lines

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

  1. {
  2. "name": "prempti-skills",
  3. "owner": {
  4. "name": "Leonardo Grasso",
  5. "email": "me@leonardograsso.com"
  6. },
  7. "metadata": {
  8. "description": "Skills for Prempti — runtime security for AI coding agents powered by Falco",
  9. "version": "0.3.0"
  10. },
  11. "plugins": [
  12. {
  13. "name": "prempti-falco-rules",
  14. "description": "Author custom Falco rules for Prempti to control what AI coding agents can do",
  15. "source": "./",
  16. "strict": false,
  17. "skills": [
  18. "./skills/prempti-falco-rules"
  19. ]
  20. }
  21. ]
  22. }
README.md · README · 429 lines

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

  1. # Prempti
  2. [![Falco Ecosystem Repository](https://github.com/falcosecurity/evolution/blob/main/repos/badges/falco-ecosystem-blue.svg)](https://github.com/falcosecurity/evolution/blob/main/REPOSITORIES.md#ecosystem-scope)
  3. [![Sandbox](https://img.shields.io/badge/status-sandbox-red?style=for-the-badge)](https://github.com/falcosecurity/evolution/blob/main/REPOSITORIES.md#sandbox)
  4. [![License](https://img.shields.io/github/license/falcosecurity/prempti?style=flat-square)](LICENSE)
  5. ![Platforms](https://img.shields.io/badge/platforms-linux%20%7C%20macOS%20%7C%20Windows-blue?style=flat-square)
  6. ![Architectures](https://img.shields.io/badge/arch-x86__64%20%7C%20aarch64-blueviolet?style=flat-square)
  7. > **Experimental Preview** — This project is under active development and released as an early preview. Interfaces and behavior may change between releases. We welcome your [feedback](#feedback) to help shape its future.
  8. ## Falco meets AI Coding Agents
  9. [![asciicast](demo.gif)](https://asciinema.org/a/lXqokxXVO4Q3IH3W)
  10. **Prempti** brings [Falco](https://falco.org) to the world of AI coding agents. It gives you guardrails that can deny or ask for confirmation on unwanted behaviors, plus real-time visibility into every tool call your coding agent makes — shell commands, file writes, reads, API calls. Both are driven by [Falco rules](https://falco.org/docs/rules/) you can customize to fit your workflow.
  11. By default, **Prempti** runs in **guardrails mode**: rules produce verdicts that shape what the agent does. When a tool call is blocked or flagged, the agent receives an LLM-friendly explanation of why and adapts — the policy guides behavior through feedback. If you prefer pure observation without intervention, switch to **monitor mode**: every tool call proceeds while rules still evaluate and log the activity.
  12. Who is this for? Anyone using a coding agent daily — developers, product managers, designers, vibe coders, and anyone else who wants to see what their agent is doing on their machine and set sensible boundaries for it.
  13. ### What It Is — and What It Isn't
  14. **It is** a cooperative policy and visibility layer at the tool-call level. It gives you an audit trail of agent activity, and guardrails the agent respects because it sees and understands them.
  15. **It is not** a sandbox, OS-level security, or a substitute for least-privilege environments or system hardening. It does not contain a determined adversarial agent. Use it alongside containment techniques — it complements them, it does not replace them.
  16. ## Features
  17. - **Real-time tool-call interception** — every shell command, file write/edit/read, web fetch, and MCP call is evaluated *before* it runs.
  18. - **Allow / deny / ask verdicts** — block, prompt for confirmation, or let it through; agents receive LLM-friendly feedback on denials and adapt.
  19. - **Two operational modes** — *guardrails* (verdicts enforced) and *monitor* (observe-only); switch any time with `premptictl mode`.
  20. - **Customizable Falco rules** — standard YAML rules; a curated default ruleset ships with the project covering common attack surfaces (credentials, sandbox-disable attempts, exfiltration, persistence, MCP/skill poisoning, and more).
  21. - **Full audit trail** — every tool call recorded with structured fields, correlatable across rule alerts.
  22. - **Cross-platform** — Linux, macOS, and Windows on x86_64 and aarch64.
  23. - **CLI included** — `premptictl` for status, health checks, mode switching, log streaming, and hook management.
  24. - **Rule-authoring skill for Claude Code** — an interactive skill to draft and validate custom rules with the help of your agent.
  25. ## How It Works
  26. When your coding agent tries to use a tool, **Prempti** intercepts the call *before* it executes, evaluates it against your rules, and produces a verdict:
  27. | Verdict | What Happens |
  28. |---------|-------------|
  29. | **Allow** | The tool call proceeds normally |
  30. | **Deny** | The tool call is blocked — the agent is told why |
  31. | **Ask** | You are prompted to approve or reject the call |
  32. Rules are standard [Falco rules](https://falco.org/docs/rules/) written in YAML. A sensible default ruleset ships with **Prempti**, and you can add your own to customize behavior for your workflow (see [Custom Rules](#custom-rules)).
  33. ### Modes
  34. - **Guardrails mode** (default) — verdicts are enforced: `deny` blocks, `ask` prompts you, `allow` proceeds.
  35. - **Monitor mode** — all tool calls proceed; verdicts are still evaluated and logged but never act on the agent. Useful for pure observation, auditing, and rule tuning.
  36. Switch between modes at any time with `premptictl mode <guardrails|monitor>`.
  37. ## When It Makes Sense
  38. - When you want to see what your coding agent is actually doing during a session, without reading every tool call by hand.
  39. - When you want to set clear boundaries — don't touch `.env` files, don't push to remote, don't write outside the project directory, etc.
  40. - When you're experimenting with a coding agent and want a safety net against accidental mistakes.
  41. - When a team wants to standardize how agents behave across members, using shareable YAML rules.
  42. - Best used alongside sandboxing, system hardening, or least-privilege environments.
  43. ## Quick Start
  44. > [!IMPORTANT]
  45. > **Migrating from `coding-agents-kit`?** Prempti does not migrate or remove existing `coding-agents-kit` installations. Uninstall `coding-agents-kit` first to avoid duplicate services or stale Claude Code hooks.
  46. ### macOS
  47. Download the universal `.pkg` installer from the [latest release](https://github.com/falcosecurity/prempti/releases/latest) and open it:
  48. ```bash
  49. open prempti-<version>-darwin-universal.pkg
  50. ```
  51. The macOS Installer wizard guides you through the setup. The service starts immediately and on every subsequent login.
  52. To install non-interactively (CI, scripted setup, SSH session):
  53. ```bash
  54. installer -pkg prempti-<version>-darwin-universal.pkg \
  55. -target CurrentUserHomeDirectory
  56. ```
  57. > [!NOTE]
  58. > Since the binaries are not code-signed, macOS Gatekeeper may block them on first run.
  59. > Go to **System Settings > Privacy & Security** and allow the blocked binary, or clear the quarantine attribute from the whole install tree (executables in `bin/` and the plugin library in `share/` can both be flagged):
  60. > ```bash
  61. > xattr -dr com.apple.quarantine ~/.prempti
  62. > ```
  63. ### Linux
  64. Download the package for your architecture from the [latest release](https://github.com/falcosecurity/prempti/releases/latest):
  65. ```bash
  66. tar xzf prempti-<version>-linux-x86_64.tar.gz
  67. cd prempti-<version>-linux-x86_64
  68. bash install.sh
  69. ```
  70. The installer copies all components to `~/.prempti/`, starts a systemd user service, and registers the hook automatically.
  71. ### Windows
  72. From the [latest release](https://github.com/falcosecurity/prempti/releases/latest), download the `.msi` for your CPU architecture and double-click it (or run `msiexec /i prempti-<version>-windows-<arch>.msi`).
  73. The MSI deploys all components to `%LOCALAPPDATA%\prempti\`, adds `bin\` to your user `PATH`, registers the Claude Code hook, registers an auto-start entry for subsequent logins, and starts the service immediately so Claude Code is protected without any extra step.
  74. > [!NOTE]
  75. > Pick the MSI that matches your CPU: `prempti-<version>-windows-x64.msi` on Intel/AMD64, `prempti-<version>-windows-arm64.msi` on Windows ARM64. The x64 MSI can install under emulation on ARM64 hosts but prefer the native ARM64 MSI for best performance. See [`installers/windows/`](installers/windows/) for build prerequisites and details.
  76. ### Verify
  77. **Linux / macOS**
  78. ```bash
  79. ~/.prempti/bin/premptictl status
  80. ~/.prempti/bin/premptictl hook status
  81. ~/.prempti/bin/premptictl health
  82. ```
  83. > **Tip:** Add `export PATH="$HOME/.prempti/bin:$PATH"` to your shell profile to use `premptictl` without the full path.
  84. **Windows**
  85. The installer starts the service automatically. Open a **new** terminal (so the updated `PATH` is picked up) and verify:
  86. ```powershell
  87. premptictl status
  88. premptictl hook status
  89. premptictl health
  90. ```
  91. Expected `health` output: `OK: pipeline healthy (synthetic event → allow)`.
  92. If the service is not running (rare — e.g. the post-install timed out), start it manually with `premptictl start`. Auto-start on every login is already registered.
  93. ## Managing
  94. The installer adds `bin/` to your shell `PATH` on Windows automatically; on Linux/macOS add it to your shell profile (see [Verify](#verify)). Once `premptictl` is on your `PATH`, the commands below are the same on every platform:
  95. ```bash
  96. # Check status
  97. premptictl status
  98. # Check pipeline health (sends a synthetic event through the full stack)
  99. premptictl health
  100. # Guardrails mode (default) — verdicts are enforced: deny blocks, ask prompts
  101. premptictl mode guardrails
  102. # Monitor mode — all tool calls proceed; verdicts are only logged
  103. premptictl mode monitor
  104. # View logs. Defaults to the last 100 lines; pass -f to follow, --tail=N to override.
  105. premptictl logs
  106. # Temporarily disable interception (tool calls proceed unmonitored)
  107. premptictl hook remove
  108. # Re-enable interception
  109. premptictl hook add
  110. # Stop / start the service
  111. premptictl stop
  112. premptictl start
  113. ```
  114. ### Uninstall
  115. **Linux / macOS**
  116. ```bash
  117. ~/.prempti/bin/premptictl uninstall
  118. # Keep your custom rules in rules/user/ for a future reinstall:
  119. ~/.prempti/bin/premptictl uninstall --keep-user-rules
  120. ```
  121. **Windows**
  122. Any of these paths works — they all run the same cleanup custom action:
  123. - Apps & Features (recommended),
  124. - `msiexec /x prempti-<version>-windows-<arch>.msi` (if you still have the MSI file),
  125. - `msiexec /x <product-code>` (the GUID is in `HKCU\Software\Microsoft\Windows\CurrentVersion\Uninstall\` under the Prempti entry).
  126. The MSI removes the Claude Code hook, the auto-start entry, and the `bin\` `PATH` entry before removing files, so Claude Code is not left in a fail-closed state.
  127. ## Default Rules
  128. The project ships with a default ruleset organized into six sections covering common attack surfaces for AI coding agents:
  129. | Section | Coverage |
  130. |---------|----------|
  131. | Working-directory boundary | Monitor and ask on file access outside the session's project directory |
  132. | Sensitive paths | Deny reads and writes to `/etc/`, `~/.ssh/`, `~/.aws/`, cloud credentials, `.env` files, etc. |
  133. | Sandbox disable | Detect attempts to disable the agent's own sandbox configuration (Claude Code, Codex, Gemini CLI) |
  134. | Threats | Credential access, destructive commands, pipe-to-shell, encoded payloads, exfiltration, IMDS access, reverse shells, supply-chain installs from known-malicious hosts |
  135. | MCP and skill content | MCP server config poisoning (`.mcp.json`) and slash-command file injection (`.claude/commands/`) |
  136. | Persistence vectors | Hook injection, git hooks, package-registry redirects, AI API base-URL overrides, API keys leaking into env files |
  137. See [`rules/default/coding_agents_rules.yaml`](rules/default/coding_agents_rules.yaml) for the full ruleset. The schema, available fields, and authoring conventions are documented in [`rules/README.md`](rules/README.md).
  138. ## Custom Rules
  139. The default ruleset is deliberately generic — it catches obviously risky actions that apply to most workflows. To get the most out of **Prempti**, you'll typically want to write your own rules tailored to your specific work: the projects you edit, the remotes you push to, the files you treat as sensitive, the commands you never want your agent to run.
  140. Add your own rules to `~/.prempti/rules/user/`. They are preserved across upgrades. You can write them by hand, or use the [rule-authoring skill](#rule-authoring-skill-for-claude-code) to have Claude Code draft and validate them for you interactively.
  141. New or edited rules take effect on the next service start — restart the service with:
  142. ```bash
  143. premptictl stop
  144. premptictl start
  145. ```
  146. Example — block piping content to shell interpreters:
  147. ```yaml
  148. - rule: Deny pipe to shell
  149. desc: Block piping content to shell interpreters
  150. condition: >
  151. tool.name = "Bash"
  152. and (tool.input_command contains "| sh"
  153. or tool.input_command contains "| bash"
  154. or tool.input_command contains "| zsh")
  155. output: >
  156. Falco blocked piping to a shell interpreter (%tool.input_command)
  157. priority: CRITICAL
  158. source: coding_agent
  159. tags: [coding_agent_deny]
  160. ```
  161. Rules are written in the standard [Falco rule language](https://falco.org/docs/rules/) (YAML). See [`rules/README.md`](rules/README.md) for all available fields and examples.
  162. ### Rule Authoring Skill for Claude Code
  163. A Claude Code [skill](https://github.com/anthropics/skills) is included to help you write custom rules interactively.
  164. Register this repository as a Claude Code Plugin marketplace:
  165. ```
  166. /plugin marketplace add falcosecurity/prempti
  167. ```
  168. Then install the skill directly:
  169. ```
  170. /plugin install prempti-falco-rules@prempti-skills
  171. ```
  172. Or browse and install interactively:
  173. 1. Select `Browse and install plugins`
  174. 2. Select `prempti-skills`
  175. 3. Select `prempti-falco-rules`
  176. 4. Select `Install now`
  177. Once installed, ask Claude Code things like:
  178. - "Block the agent from running git push"
  179. - "Deny any read outside the working directory"
  180. - "Create a rule that requires confirmation before editing Dockerfiles"
  181. The skill guides Claude through writing the rule, placing it in the right directory, and validating it with Falco.
  182. ## Supported Agents & Platforms
  183. | Agent | Platform | Status |
  184. |-------|----------|--------|
  185. | [Claude Code](https://docs.anthropic.com/en/docs/claude-code) | Linux (x86_64, aarch64) | Supported |
  186. | [Claude Code](https://docs.anthropic.com/en/docs/claude-code) | macOS (Apple Silicon, Intel) | Supported |
  187. | [Claude Code](https://docs.anthropic.com/en/docs/claude-code) | Windows (x86_64, ARM64) | Supported |
  188. | [Codex](https://openai.com/index/codex/) | Linux | Experimental |
  189. [Codex](https://openai.com/index/codex/) support landed as the experimental `codex-interceptor` binary in `hooks/codex/` — the wire envelope, plugin field schema, default ruleset, and `apply_patch` multi-file handling all work end-to-end on Linux. macOS and Windows are likely to work too (the interceptor is cross-platform Rust) but are unverified at this time. Register the hook with `premptictl hook add codex`; full installer integration (binary packaging, supervisor-managed lifecycle alongside Claude's) is still in progress. See [`hooks/codex/README.md`](hooks/codex/README.md) for setup details including Codex's hook-trust requirement.
  190. ## Building from Source
  191. <details>
  192. <summary><strong>Linux</strong></summary>
  193. Requires: Rust (latest stable)
  194. ```bash
  195. make linux # Both architectures
  196. make linux-x86_64 # x86_64 only
  197. make linux-aarch64 # aarch64 only (requires cross toolchain)
  198. ```
  199. Output: `build/prempti-<version>-linux-{arch}.tar.gz`
  200. See [`installers/linux/`](installers/linux/) for details.
  201. </details>
  202. <details>
  203. <summary><strong>macOS</strong></summary>
  204. Requires: Rust (latest stable), CMake >= 3.24, Xcode Command Line Tools, OpenSSL via Homebrew
  205. ```bash
  206. # Install prerequisites
  207. xcode-select --install
  208. brew install cmake openssl@3
  209. curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
  210. # Build
  211. make macos # Native architecture of the host
  212. make macos-aarch64 # Apple Silicon
  213. make macos-x86_64 # Intel (native on Intel, or Rosetta cross-compile on Apple Silicon)
  214. make macos-universal # Universal binary (requires Rosetta + x86_64 Homebrew)
  215. ```
  216. Output: `build/prempti-<version>-darwin-<arch>.{tar.gz,pkg}`
  217. Install the locally-built artifact with either:
  218. ```bash
  219. open build/prempti-<version>-darwin-<arch>.pkg # GUI wizard
  220. # or, non-interactive:
  221. installer -pkg build/prempti-<version>-darwin-<arch>.pkg \
  222. -target CurrentUserHomeDirectory
  223. # or, from the tarball:
  224. tar xzf build/prempti-<version>-darwin-<arch>.tar.gz -C /tmp
  225. bash /tmp/prempti-<version>-darwin-<arch>/install.sh
  226. ```
  227. > Falco does not ship pre-built macOS binaries. The first build compiles Falco from source (~5 min). Subsequent builds use the cached binary.
  228. See [`installers/macos/`](installers/macos/) for details.
  229. </details>
  230. <details>
  231. <summary><strong>Windows</strong></summary>
  232. Requires: Rust (latest stable), Visual Studio 2022+ with C++ workload, CMake 3.24+, vcpkg with curl, .NET Runtime 9+, WiX Toolset v7.
  233. ```powershell
  234. powershell -ExecutionPolicy Bypass -File installers\windows\package.ps1
  235. ```
  236. Output: `build/out/prempti-<version>-windows-<arch>.msi`.
  237. > Falco is built from source on the first run (~10 min). Subsequent builds use the cached binary.
  238. See [`installers/windows/`](installers/windows/) for detailed prerequisites and build options.
  239. </details>
  240. <details>
  241. <summary><strong>Individual Components</strong></summary>
  242. ```bash
  243. make build # All components (interceptor, plugin, CLI tool)
  244. make build-interceptor # Interceptor only
  245. make build-plugin # Falco plugin only
  246. make build-ctl # CLI tool only
  247. make falco-macos # Falco binary (macOS only)
  248. ```
  249. </details>
  250. ## Architecture
  251. ```
  252. ┌──────────────┐ ┌──────────────┐ ┌────────────────────────────┐
  253. │ Coding Agent │─────>│ Interceptor │─────>│ Falco (nodriver) │
  254. │ │ │ (hook) │ │ ┌───────────────────────┐ │
  255. │ │<─────│ │<─────│ │ Plugin (src + extract│ │
  256. │ │ │ │ │ │ + embedded broker) │ │
  257. └──────────────┘ └──────────────┘ │ └───────────────────────┘ │
  258. │ Rule Engine + Rules │
  259. └────────────────────────────┘
  260. ```
  261. 1. The coding agent's hook fires before each tool call
  262. 2. The **interceptor** sends the event to the plugin's embedded broker via Unix socket
  263. 3. The **plugin** feeds the event to Falco's rule engine
  264. 4. Matching rules produce verdicts (deny/ask/allow)
  265. 5. The **interceptor** delivers the verdict back to the coding agent
  266. For design decisions, component specs, and full architectural documentation, see [CLAUDE.md](CLAUDE.md).
  267. ## Known Limitations
  268. ### Hook-level interception
  269. **Prempti** intercepts tool calls at the coding agent's hook API — it sees the commands the agent asks to run, not the side effects those commands produce on the system.
  270. This means that if a coding agent embeds harmful logic in a source file, compiles it, and then runs the resulting binary, Falco can inspect the compile and run commands but cannot analyze what the compiled program actually does at runtime. The rules see `gcc main.c -o main` and `./main`, not the system calls that `./main` makes.
  271. Coverage is therefore asymmetric:
  272. - Strongest for structured tools such as `Write`, `Edit`, and `Read`, where the agent exposes first-class file semantics.
  273. - Weaker for generic tools such as `Bash`, where rules evaluate the declared command rather than fully resolved shell behavior.
  274. - Input-side only for external systems such as MCP, where **Prempti** can inspect the requested call but not the side effects the MCP server later performs.
  275. In practice, guardrails mode can block many unsafe or out-of-policy tool calls, but it is not OS-level containment and should not be treated as a hard boundary. For deeper visibility — detecting what processes actually do at the syscall level — Falco's kernel instrumentation (eBPF/kmod) is the right tool (at least for Linux).
  276. ## Feedback
  277. Policy and visibility for AI coding agents is new territory — we're learning alongside the community.
  278. If you're using **Prempti**, we'd love to hear from you:
  279. - **What works?** What rules have you written? What did you catch?
  280. - **What's missing?** What agents or platforms do you need?
  281. - **What broke?** What didn't work as expected?
  282. Your experience directly shapes where this project goes next. Open an [issue](https://github.com/falcosecurity/prempti/issues), or reach out to the maintainers. Every bit of feedback helps.
  283. ## Credits
  284. **Prempti** was built with significant assistance from [Claude Code](https://github.com/anthropics/claude-code).
  285. Initial research and ideation by [Leonardo Grasso](https://github.com/leogr), [Loris Degioanni](https://github.com/ldegio), and [Michael Clark](https://github.com/MikeC-Sysdig).
  286. Support and testing by [Alessandro Cannarella](https://github.com/c2ndev), [Iacopo Rozzo](https://github.com/irozzo-1a), and [Leonardo Di Giovanna](https://github.com/ekoops).
  287. ## License
  288. Apache License 2.0. See [LICENSE](LICENSE).

Ratings and comments

Sign in to rate this skill.

Sign in

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