# Acroform Writer > Use this skill whenever the user wants values written INTO an existing PDF form that lives in the connected SharePoint knowledge source — filling out, completing, populating, or submitting a fillable PDF (application, intake sheet, contract, government form) from data they supply, a spreadsheet row, or the conversation. Triggers include "fill out the job application form", "complete the intake form for [person]", "populate our standard NDA template", and "make this ready to send / non-editable" (flatten). The source form should be found via knowledge search; only ask the user to upload it if knowledge search turns up nothing plausible. different task), and do NOT use it on scanned/image-only PDFs that have no real fillable fields — those need OCR or manual overlay instead, which this skill explicitly detects and reports rather than silently failing. - Skill: `kody-w/acroform-writer` (Agent Skill, multi-file: 4 files) - Install (CLI): `npx skillmds@latest add kody-w/acroform-writer` - Raw SKILL.md: https://api.skillmd.com/api/skills/kody-w/acroform-writer/raw - Safety review: pending - Works with: Claude Code, Claude.ai, OpenAI Codex - Category: Data & Analytics - Author: kody-w (https://skillmd.com/u/kody-w) - Updated: 2026-09-17 - Page: https://skillmd.com/skills/kody-w/acroform-writer --- Fill an existing PDF's real AcroForm fields with supplied data, and optionally lock the result read-only so it's ready to send or file without further edits. The goal is to write into the document's actual form fields — never to paste text over a rendered page image, which drifts out of alignment the moment a layout differs even slightly from what you assumed. ## Instructions 1. **Find the source PDF via knowledge search — do not ask the user to upload it.** The blank fillable form (e.g. a job application, intake sheet, or contract template) lives in the connected SharePoint knowledge source, not as a user upload. Let the user refer to it naturally — by form name, topic, or purpose ("the job application form", "our standard NDA template") — and use those cues to search knowledge for the best-matching PDF. If exactly one document is a clear match, proceed with it; only ask a brief clarifying question when the match is genuinely ambiguous (multiple similarly-named forms, or no clear candidate). 2. **Pull the FULL document, not retrieved chunks.** A knowledge search only needs to return enough to *find* the right file — form fields and their full structure can be split or omitted across retrieval chunks. Once the right document is identified, fetch the complete PDF into the sandbox (the SharePoint knowledge source handles this — let it pull the full file down) before doing anything else. Never attempt to reconstruct or fill a form from a partial/chunked view of it. 3. **Collect the values to fill.** These come from the conversation, an attached spreadsheet row, or a connector record — collect them into a flat `{field_name: value}` JSON object. Do not guess field names at this stage; that happens against the PDF's real fields in the next step. 4. **Always list fields first.** Run: ``` python scripts/fill_form.py list ``` This prints every real form field (name, type, current value, and — for checkboxes/radios/dropdowns — the valid states or options). Use this output to map the data you collected in step 3 onto the PDF's actual field names. **If this reports no fields found (exit code 1), stop** — the PDF has no real AcroForm (commonly a scanned or flattened document already). Tell the user this form isn't fillable this way and don't attempt to fake it by drawing text over the page. 5. **Match data to fields carefully.** - Checkboxes/radio buttons must be set to one of the exact `states` values reported in step 4 (typically `/Yes` and `/Off`), not `true`/`false`. - Dropdown/choice fields must use one of the reported `options` values verbatim. - If a value you were given doesn't obviously map to any listed field, do not force it into the closest-sounding one — leave it out and flag it to the user rather than guessing. 6. **Fill (and lock read-only, if the result should be final):** ``` python scripts/fill_form.py fill [--flatten] ``` Add `--flatten` whenever the output is meant to be a finished, submission- ready document (the common case) so the fields are marked read-only and most viewers treat it as no longer editable. This is a best-effort lock, not true flattening — the AcroForm and field definitions still exist in the file, and a viewer that ignores the read-only flag could still edit them. Leave `--flatten` off if the user explicitly wants to keep the fields freely editable for further changes later. 7. **Check the JSON result the script prints.** It reports `fields_filled` and any `unmatched_fields` — data keys that didn't correspond to a real field. Always surface unmatched fields to the user by name; never fill silently and claim full completion if something was dropped. 8. **Hand back the file with a short, honest recap:** which form (and, if relevant, where it was sourced from in knowledge), how many fields were filled, whether it was flattened, and any fields left blank or unmatched. Do not paste the filled values back into the chat as a table — the file is the deliverable. ## Guardrails - Never ask the user to upload the blank form — find it via knowledge search first. Only fall back to asking the user directly for the file if knowledge search turns up nothing plausible at all. - Never fill from a partially retrieved/chunked view of the form — always work from the complete downloaded PDF (step 2). - Never draw or overlay text on a page image to fake-fill a PDF that has no real form fields — detect that case (step 4) and say so plainly instead. - Never invent a value for a field the user didn't supply; leave it blank and say so. - Never force a supplied value into a checkbox/radio/dropdown field using anything other than that field's own reported states/options. - Don't silently drop unmatched data — always report it. - `--flatten` is about locking the PDF read-only, not about changing any of the entered values — never alter data during that step. ## Tone Precise and matter-of-fact. State plainly what was filled, what wasn't, and why — this skill is often used for documents with real consequences (applications, contracts), so avoid overstating completeness. ## Run this — do not improvise This capability's deterministic implementation is a RAPP single-file agent, linked beside this file as `acroform_writer_agent.py` and embedded as the fenced Python below (sha256 575665366a0181a5…; a byte-exact copy is also vaulted in the capsule comment at the end of this file). On a host with sandbox execution, run the linked file directly — if it is missing, write the fence contents verbatim to `acroform_writer_agent.py` first: ```bash python3 acroform_writer_agent.py '{"key": "value"}' # arguments as one JSON object echo '{"key": "value"}' | python3 acroform_writer_agent.py # or on stdin python3 acroform_writer_agent.py --tool # emit the JSON tool contract ``` Treat stdout as a tool result. If it reports missing or unresolved inputs, stop and collect them. If it returns `steps`, execute those steps in order exactly as returned; if it returns `instructions`, follow them with the supplied inputs. Otherwise use the result verbatim. Do not invent behavior beyond that output. On a host without code execution, treat the Parameters schema and the code below as the exact specification and never paraphrase a step. Never edit inside the generated markers; a converter-equipped host can instead restore the original file checksum-verified with the installed `rapp-agent-converter/scripts/toast.py convert SKILL.md --to agent`. ````python # rapp:deterministic """AcroformWriter -- Use this skill whenever the user wants values written INTO an existing PDF form that lives in the connected SharePoint knowledge source — filling out, completing, populating, or submitting a fillable PDF (application, intake sheet, contract, government form) from data they supply, a spreadsheet row, or the conversation. Triggers include "fill out the job application form", "complete the intake form for [person]", "populate our standard NDA template", and "make this ready to send / non-editable" (flatten). The source form should be found via knowledge search; only ask the user to upload it if knowledge search turns up nothing plausible. different task), and do NOT use it on scanned/image-only PDFs that have no real fillable fields — those need OCR or manual overlay instead, which this skill explicitly detects and reports rather than silently failing. Generated by the rapp skill from acroform-writer. The RCI capsule at the bottom of this file carries the full original; `toast.py convert` restores it byte-exact.""" import json import re import sys try: from agents.basic_agent import BasicAgent except ImportError: # running OUTSIDE a brainstem -- stay executable anyway. class BasicAgent: # noqa: D101 - minimal stand-in, same contract def __init__(self, name=None, metadata=None): if name: self.name = name if metadata: self.metadata = metadata def perform(self, **kwargs): return "Not implemented." def system_context(self): return None def to_tool(self): return {"type": "function", "function": { "name": self.name, "description": self.metadata.get("description", ""), "parameters": self.metadata.get("parameters", {})}} # The procedural layer, verbatim from the source capability. INSTRUCTIONS = 'Fill an existing PDF's real AcroForm fields with supplied data, and\noptionally lock the result read-only so it's ready to send or file without\nfurther edits. The goal is to write into the document's actual form fields —\nnever to paste text over a rendered page image, which drifts out of\nalignment the moment a layout differs even slightly from what you assumed.\n\n## Instructions\n1. **Find the source PDF via knowledge search — do not ask the user to upload it.**\n The blank fillable form (e.g. a job application, intake sheet, or contract\n template) lives in the connected SharePoint knowledge source, not as a user\n upload. Let the user refer to it naturally — by form name, topic, or\n purpose ("the job application form", "our standard NDA template") — and use\n those cues to search knowledge for the best-matching PDF. If exactly one\n document is a clear match, proceed with it; only ask a brief clarifying\n question when the match is genuinely ambiguous (multiple similarly-named\n forms, or no clear candidate).\n2. **Pull the FULL document, not retrieved chunks.** A knowledge search only\n needs to return enough to *find* the right file — form fields and their\n full structure can be split or omitted across retrieval chunks. Once the\n right document is identified, fetch the complete PDF into the sandbox (the\n SharePoint knowledge source handles this — let it pull the full file down)\n before doing anything else. Never attempt to reconstruct or fill a form\n from a partial/chunked view of it.\n3. **Collect the values to fill.** These come from the conversation, an\n attached spreadsheet row, or a connector record — collect them into a flat\n `{field_name: value}` JSON object. Do not guess field names at this stage;\n that happens against the PDF's real fields in the next step.\n4. **Always list fields first.** Run:\n ```\n python scripts/fill_form.py list \n ```\n This prints every real form field (name, type, current value, and — for\n checkboxes/radios/dropdowns — the valid states or options). Use this output\n to map the data you collected in step 3 onto the PDF's actual field names.\n **If this reports no fields found (exit code 1), stop** — the PDF has no\n real AcroForm (commonly a scanned or flattened document already). Tell the\n user this form isn't fillable this way and don't attempt to fake it by\n drawing text over the page.\n5. **Match data to fields carefully.**\n - Checkboxes/radio buttons must be set to one of the exact `states` values\n reported in step 4 (typically `/Yes` and `/Off`), not `true`/`false`.\n - Dropdown/choice fields must use one of the reported `options` values\n verbatim.\n - If a value you were given doesn't obviously map to any listed field, do\n not force it into the closest-sounding one — leave it out and flag it to\n the user rather than guessing.\n6. **Fill (and lock read-only, if the result should be final):**\n ```\n python scripts/fill_form.py fill [--flatten]\n ```\n Add `--flatten` whenever the output is meant to be a finished, submission-\n ready document (the common case) so the fields are marked read-only and\n most viewers treat it as no longer editable. This is a best-effort lock,\n not true flattening — the AcroForm and field definitions still exist in\n the file, and a viewer that ignores the read-only flag could still edit\n them. Leave `--flatten` off if the user explicitly wants to keep the\n fields freely editable for further changes later.\n7. **Check the JSON result the script prints.** It reports `fields_filled` and\n any `unmatched_fields` — data keys that didn't correspond to a real field.\n Always surface unmatched fields to the user by name; never fill silently\n and claim full completion if something was dropped.\n8. **Hand back the file with a short, honest recap:** which form (and, if\n relevant, where it was sourced from in knowledge), how many fields were\n filled, whether it was flattened, and any fields left blank or unmatched.\n Do not paste the filled values back into the chat as a table — the file is\n the deliverable.\n\n## Guardrails\n- Never ask the user to upload the blank form — find it via knowledge search\n first. Only fall back to asking the user directly for the file if knowledge\n search turns up nothing plausible at all.\n- Never fill from a partially retrieved/chunked view of the form — always\n work from the complete downloaded PDF (step 2).\n- Never draw or overlay text on a page image to fake-fill a PDF that has no\n real form fields — detect that case (step 4) and say so plainly instead.\n- Never invent a value for a field the user didn't supply; leave it blank and\n say so.\n- Never force a supplied value into a checkbox/radio/dropdown field using\n anything other than that field's own reported states/options.\n- Don't silently drop unmatched data — always report it.\n- `--flatten` is about locking the PDF read-only, not about changing any of\n the entered values — never alter data during that step.\n\n## Tone\nPrecise and matter-of-fact. State plainly what was filled, what wasn't, and\nwhy — this skill is often used for documents with real consequences\n(applications, contracts), so avoid overstating completeness.' # Ordered commands lifted verbatim from the capability's own documentation. STEPS = [] class AcroformWriterAgent(BasicAgent): def __init__(self): self.name = 'AcroformWriter' self.metadata = { "name": "AcroformWriter", "description": "Use this skill whenever the user wants values written INTO an existing PDF form that lives in the connected SharePoint knowledge source \u2014 filling out, completing, populating, or submitting a fillable PDF (application, intake sheet, contract, government form) from data they supply, a spreadsheet row, or the conversation. Triggers include \"fill out the job application form\", \"complete the intake form for [person]\", \"populate our standard NDA template\", and \"make this ready to send / non-editable\" (flatten). The source form should be found via knowledge search; only ask the user to upload it if knowledge search turns up nothing plausible. different task), and do NOT use it on scanned/image-only PDFs that have no real fillable fields \u2014 those need OCR or manual overlay instead, which this skill explicitly detects and reports rather than silently failing.", "parameters": { "type": "object", "properties": {}, "required": [] } } super().__init__(name=self.name, metadata=self.metadata) def perform(self, **kwargs): # toaster:generated-perform return json.dumps({"status": "ok", "instructions": INSTRUCTIONS, "inputs": kwargs, "note": "Prose-only capability: follow INSTRUCTIONS " "with the given inputs."}, indent=2) if __name__ == "__main__": # echo '{"arg": "value"}' | python3 acroform_writer_agent.py # python3 acroform_writer_agent.py '{"arg": "value"}' # python3 acroform_writer_agent.py --tool # emit the JSON tool contract _a = sys.argv[1:] if _a and _a[0] == "--tool": print(json.dumps(AcroformWriterAgent().to_tool(), indent=2)) else: _raw = _a[0] if _a else (sys.stdin.read().strip() or "{}") print(AcroformWriterAgent().perform(**json.loads(_raw))) # rci-capsule:v1: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 ````