home / skills / openclaw / skills / form-builder

This skill helps you build interactive docassemble forms and conditional questionnaires for documents and interviews.

npx playbooks add skill openclaw/skills --skill form-builder

Review the files below or copy the command above to add this skill to your agents.

Files (2)
SKILL.md
4.1 KB
---
name: form-builder
description: Build interactive document forms and questionnaires using docassemble
author: claude-office-skills
version: "1.0"
tags: [forms, questionnaire, docassemble, automation, legal]
models: [claude-sonnet-4, claude-opus-4]
tools: [computer, code_execution, file_operations]
library:
  name: docassemble
  url: https://github.com/jhpyle/docassemble
  stars: 919
---

# Form Builder Skill

## Overview

This skill enables creation of intelligent document forms using **docassemble** - a platform for guided interviews that generate documents. Create questionnaires that adapt based on answers.

## How to Use

1. Describe the form or document you need
2. Specify conditional logic requirements
3. I'll create docassemble interview YAML

**Example prompts:**
- "Create an intake form for new clients"
- "Build a conditional questionnaire for legal documents"
- "Generate a multi-step form for contract generation"
- "Design an interactive document assembly form"

## Domain Knowledge

### Interview Structure

```yaml
metadata:
  title: Client Intake Form
  short title: Intake

---
question: |
  What is your name?
fields:
  - First Name: first_name
  - Last Name: last_name

---
question: |
  What type of service do you need?
field: service_type
choices:
  - Contract Review
  - Document Drafting
  - Consultation

---
mandatory: True
question: |
  Thank you, ${ first_name }!
subquestion: |
  We will contact you about your ${ service_type } request.
```

### Conditional Logic

```yaml
---
question: |
  Are you a business or individual?
field: client_type
choices:
  - Business
  - Individual

---
if: client_type == "Business"
question: |
  What is your company name?
fields:
  - Company: company_name
  - EIN: ein
    required: False

---
if: client_type == "Individual"
question: |
  What is your date of birth?
fields:
  - Birthdate: birthdate
    datatype: date
```

### Field Types

```yaml
fields:
  # Text
  - Name: name
  
  # Email
  - Email: email
    datatype: email
  
  # Number
  - Age: age
    datatype: integer
  
  # Currency
  - Amount: amount
    datatype: currency
  
  # Date
  - Start Date: start_date
    datatype: date
  
  # Yes/No
  - Agree to terms?: agrees
    datatype: yesno
  
  # Multiple choice
  - Color: color
    choices:
      - Red
      - Blue
      - Green
  
  # Checkboxes
  - Select options: options
    datatype: checkboxes
    choices:
      - Option A
      - Option B
  
  # File upload
  - Upload document: document
    datatype: file
```

### Document Generation

```yaml
---
mandatory: True
question: |
  Your document is ready.
attachment:
  name: Contract
  filename: contract
  content: |
    # Service Agreement
    
    This agreement is between **${ client_name }**
    and **Service Provider**.
    
    ## Services
    ${ service_description }
    
    ## Payment
    Total amount: ${ currency(amount) }
    
    Date: ${ today() }
```

## Example: Client Intake

```yaml
metadata:
  title: Legal Client Intake
  short title: Intake

---
objects:
  - client: Individual

---
question: |
  Welcome to our intake form.
subquestion: |
  Please answer the following questions.
continue button field: intro_screen

---
question: |
  What is your name?
fields:
  - First Name: client.name.first
  - Last Name: client.name.last
  - Email: client.email
    datatype: email
  - Phone: client.phone
    required: False

---
question: |
  What type of matter is this?
field: matter_type
choices:
  - Contract: contract
  - Dispute: dispute
  - Advisory: advisory

---
if: matter_type == "contract"
question: |
  Contract Details
fields:
  - Contract Type: contract_type
    choices:
      - Employment
      - Service Agreement
      - NDA
  - Other Party: other_party
  - Estimated Value: contract_value
    datatype: currency

---
mandatory: True
question: |
  Thank you, ${ client.name.first }!
subquestion: |
  **Summary:**
  
  - Name: ${ client.name }
  - Email: ${ client.email }
  - Matter: ${ matter_type }
  
  We will contact you within 24 hours.
```

## Resources

- [docassemble Documentation](https://docassemble.org/docs.html)
- [GitHub Repository](https://github.com/jhpyle/docassemble)

Overview

This skill builds interactive document forms and guided questionnaires using docassemble. It generates interview YAML, conditional logic, field definitions, and document attachments so you can assemble tailored documents from user responses. Use it to create intake forms, contract builders, and multi-step interviews that adapt to answers.

How this skill works

Describe the form you need and specify conditional rules or data types. The skill outputs docassemble-compatible YAML: metadata, question blocks, fields, conditionals (if statements), object definitions, and attachment templates. It also supports common field datatypes (email, date, currency, checkboxes, file) and inserts values into generated documents.

When to use it

  • You need a guided intake or client questionnaire for legal, HR, or service workflows.
  • You want conditional branching based on user answers (e.g., business vs individual).
  • You need an automated document assembly that fills templates from interview data.
  • You want to prototype multi-step forms quickly in docassemble format.
  • You require file uploads, signature fields, or structured data capture.

Best practices

  • Define the desired end document and key data fields before building the interview.
  • Keep questions short and group related fields into single blocks for clarity.
  • Use explicit datatypes for validation (email, date, currency, integer).
  • Model conditional logic with clear variables and test all branches with sample answers.
  • Include summary and confirmation screens to let users review captured data before generating documents.

Example use cases

  • Client intake form that captures contact info, matter type, and generates a summary PDF.
  • Conditional contract generator that asks relevant clauses based on contract type and parties.
  • Employment onboarding questionnaire that collects personal details, tax info, and uploads documents.
  • Legal matter triage that routes users through different question sets for disputes, contracts, or advisory work.
  • Multi-step service agreement builder producing a completed agreement with inserted values and dates.

FAQ

Do I need docassemble installed to use the output?

Yes. The YAML produced is meant to be run within a docassemble instance or integrated environment that supports docassemble interviews.

Can the skill create file upload fields and attach generated documents?

Yes. It supports file datatype fields for uploads and attachment blocks for generating documents from interview variables.

How do I test conditional logic?

Use representative sample answers to run through each branch in docassemble. Include mandatory flags where needed to exercise required paths.