Skip to content

ThomasMoreAI/legal-skills-open / ar/contracts/skills/ai-automation-contracts-aurelioagency

ai-automation-contracts-aurelioagency

Verified

Genera contratos en derecho argentino para vender proyectos de automatización con IA — implementación llave en mano, mantenimiento con abono mensual y órdenes de trabajo puntuales — a partir de los datos del proyecto, y los entrega en Word listos para firmar. Usar SIEMPRE que el usuario mencione contrato, contrato de servicios, contrato de implementación, contrato de mantenimiento, orden de trabajo, anexo técnico, cláusulas, alcance contractual, propiedad intelectual de un desarrollo, garantía de un sistema entregado, o cuando cierre un proyecto con un cliente y necesite formalizarlo. Usar también cuando pregunte qué datos necesita pedirle al cliente antes de firmar, cuando quiera revisar o modificar una cláusula, o cuando describa un proyecto vendido y haya que documentarlo — aunque no diga la palabra "contrato".

FileKindSize
LICENSEother1.0 KB
README.mdmarkdown10.1 KB
SKILL.mdskill md7.7 KB
assets/defaults.jsonconfig2.0 KB
assets/implementacion.mdmarkdown29.9 KB
assets/logo.pngbinary356.6 KB
assets/mantenimiento.mdmarkdown10.0 KB
assets/orden-trabajo.mdmarkdown2.7 KB
references/intake.mdmarkdown5.2 KB
scripts/generar_contrato.pyscript8.3 KB
# AI Automation Contracts — Contract Generation Skill

An agent skill that drafts ready-to-sign contracts, worded in the provider's favor, for the turnkey automation-with-AI business model:

```
project data → templates (implementation / maintenance / work order) → filled .docx → PDF check → deliver
```

It covers the three documents a typical automation sale needs — the full turnkey **implementation** contract, an optional monthly **maintenance** retainer, and one-page **work orders** for one-off return visits — with a fixed set of provider-favorable policy decisions (IP split, liability cap, tacit acceptance, three-layer AI performance standard) already baked into the templates.

Works with agent harnesses that support file-based skills (Claude Code, Codex, and similar).

## What's in this folder

| Path | Purpose |
|---|---|
| [SKILL.md](SKILL.md) | The skill itself: workflow, redaction rules, fixed policy decisions |
| [references/intake.md](references/intake.md) | Full intake checklist, grouped by block, marking what comes from the client vs. what the provider decides |
| [assets/implementacion.md](assets/implementacion.md) | Template: the full implementation contract, legal body plus Annexes I and II |
| [assets/mantenimiento.md](assets/mantenimiento.md) | Template: monthly maintenance retainer (hours included, response time, auto-renewal) |
| [assets/orden-trabajo.md](assets/orden-trabajo.md) | Template: one-page work order for a punctual intervention |
| [assets/defaults.json](assets/defaults.json) | Default values for every policy variable (deadlines, thresholds, standard clauses) — edit here to change policy across all future contracts |
| [scripts/generar_contrato.py](scripts/generar_contrato.py) | Fills a template's `{{PLACEHOLDERS}}` from a data JSON and builds the formatted `.docx` |

## Key features

- **Three documents, one dependency chain** — implementation is always generated and is the document the other two lean on; maintenance and work orders reference it instead of repeating its legal body. Selling implementation plus a retainer never produces a fourth document: both are generated and signed together, deliberately, so cancelling the retainer never affects the implementation already delivered.
- **Intake that doesn't stall on missing data** — `references/intake.md` gives the full checklist by block; the agent asks only what's missing and relevant, in short grouped batches, and cross-checks against a commercial proposal you already sent the client instead of re-asking. Fields still open when generation runs come out marked `[COMPLETAR: X]` in red in the document, and are listed at the end — the contract is never blocked waiting on a detail.
- **Policy fixed in the templates, not improvised per contract** — obligation of means, not results, a three-layer AI performance standard (deterministic actions, a 90% threshold for verifiable AI roles, no metric on writing quality, with three separate exclusions), split IP (the specific build assigned in full but non-exclusive; base components — flow templates, prompt libraries, architectures — retained with reuse rights, licensed to the client to operate and modify), unrestricted publicity rights over the delivered work, a 30-day warranty with broad exclusions and a fix-only remedy, tacit acceptance at 7 days, client non-collaboration timeouts, and a 50%-of-price liability cap. All documented in [SKILL.md](SKILL.md) so the agent can explain any of them if a client objects.
- **Content-block redaction, not fill-in-the-blank** — variables like `ALCANCE_INCLUIDO`, `ROLES_IA`, `CRITERIOS_ACEPTACION`, `ESQUEMA_PAGOS` and `ACCESOS_REQUERIDOS` are drafted in legal register as short bulleted lists, not copied verbatim from conversational input, and acceptance criteria are always written as verifiable system behavior — never "client satisfaction."
- **Local, dependency-light `.docx` generation** — `scripts/generar_contrato.py` renders the filled markdown into a formatted Word document (Calibri 10.5, justified body, page break before each Annex) with no network calls and no paid API; the only dependency is `python-docx`.
- **Built-in PDF check before delivery** — the workflow converts the generated `.docx` to PDF and inspects at least the first page and the signature page before handing it over.
- **One mandatory warning, not repeated** — the first contract of a series reminds you this template needs a one-time review by a lawyer in your own jurisdiction before real clients sign it; the skill produces a consistent, provider-favorable, reusable document, and that single legal review is what makes it safe to reuse indefinitely.

## Installation

**Option A — let your agent install it (recommended).** Open Claude Code and paste:

```text
Install the ai-automation-contracts skill from https://github.com/aurelioagency/skills :
1. Run: git clone --filter=blob:none --sparse https://github.com/aurelioagency/skills.git into a temporary folder.
2. Inside it, run: git sparse-checkout set ai-automation-contracts
3. Copy the ai-automation-contracts/ folder into ~/.claude/skills/ai-automation-contracts/
4. Delete the temporary clone and confirm the skill loads.
5. Check the requirements: Python 3 and python-docx (pip install python-docx).
   Install anything missing (ask me to approve each install command).
6. Explain how to use the skill and ask me if we draft my first contract now.
```

The agent fetches only this skill (not the whole collection), installs it permanently in `~/.claude/skills/` for all future chats, and walks you into your first job.

**Option B — manual.** Clone the repo and run the bundled installer:

```powershell
git clone https://github.com/aurelioagency/skills.git
cd skills
node install-skills.mjs ai-automation-contracts          # Claude Code
node install-skills.mjs ai-automation-contracts --codex  # Codex
```

Any other harness: point it at this folder's `SKILL.md`.

## Updating

Improvements land in this repo; your installed copy never updates itself. To update, re-run the installer — it replaces the installed skill cleanly, records the installed commit in `.installed-from.json`, and prints the old and new commits. Open Claude Code and paste:

```text
Update my installed ai-automation-contracts skill from https://github.com/aurelioagency/skills :
1. If I have a clone of the repo, run git pull in it; otherwise make a temporary
   sparse clone like in the install prompt.
2. In the clone, run: node install-skills.mjs ai-automation-contracts
3. The installer prints the previous and new commit. Summarize what changed
   between them (git log --oneline <old>..<new> -- ai-automation-contracts) in my language.
4. Confirm the skill still loads. Delete the temporary clone if you made one.
```

To find out whether you are behind without installing anything, run this in an up-to-date clone:

```powershell
node install-skills.mjs ai-automation-contracts --check
```

It compares the commit recorded in your installed copy against the checkout, counting only commits that touch this skill (exit code 3 means an update is available). Teams working on the repo can keep a permanent clone: updating is just `git pull` + the installer command.

> **Careful if you improved your installed copy by hand.** The installer replaces the skill's files. Anything you edited inside `~/.claude/skills/ai-automation-contracts/` that was never committed to the repo is lost on update — this applies especially to `assets/defaults.json` if you tuned it locally. Bring changes to the repo first.

## Uninstalling

The installed skill lives entirely in one folder: `~/.claude/skills/ai-automation-contracts/`. Removing it never touches contracts you already generated (they live in your own project folders), other installed skills, or any clone of this repo. Open Claude Code and paste:

```text
Remove the ai-automation-contracts skill from my machine:
1. Delete the folder ~/.claude/skills/ai-automation-contracts/ (all of it).
2. Confirm the skill no longer loads. Do not touch my generated contracts,
   other installed skills, or any clone of the skills repo.
```

Or manually — from a clone of the repo:

```powershell
node install-skills.mjs ai-automation-contracts --remove
```

(which only deletes the installed copy, never the repo folder), or simply delete `~/.claude/skills/ai-automation-contracts/` yourself.

## Requirements

- **Python 3** on `PATH`.
- **`python-docx`** (`pip install python-docx`) — builds the formatted `.docx`.
- A PDF-conversion path for the delivery check (e.g. LibreOffice's `soffice` headless mode) plus `pdftoppm` to render the check pages — optional but recommended before handing a contract over.
- **No API keys and no paid providers** — everything runs locally.

## Usage

Once installed, the skill lives in `~/.claude/skills/ai-automation-contracts/` and is available in **every** Claude Code session on the machine, forever. Nothing is re-installed per contract.

Trigger it by describing the job, for example:

> Necesito el contrato de implementación para el proyecto que le cerré a `<cliente>`

> Armame implementación más mantenimiento para este proyecto

> Orden de trabajo para `<cliente>`, volvió a pedir un ajuste

From there the skill:

1. Confirms which documents are needed (implementation alone, or implementation plus maintenance).
2. Reads `references/intake.md` and asks only for what's missing, in short grouped batches, cross-checking against anything you already gave it (a commercial proposal often already covers scope, timeline, price and platforms).
3. Builds a `datos.json` from `assets/defaults.json` overridden with the project's own data.
4. Runs `scripts/generar_contrato.py` to produce the formatted `.docx`.
5. Converts to PDF and checks the first page and the signature page.
6. Delivers the file and lists any field still marked `[COMPLETAR: X]`.

### Editing policy defaults

`assets/defaults.json` holds every variable with a standard value (deadlines, thresholds, boilerplate exclusions). Edit it directly to change policy across every future contract — client-specific data always overrides it per project and is never written back into the defaults.

## License

MIT — see [LICENSE](../LICENSE) at the repo root.
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 196kUpdated Claude CodeCodexVerifiedInstall