# The 8-field form: why agents collect what the schema has, not what the job needs

> Agents build forms from data models. A schema with twelve fields produces a form with twelve fields. The job usually requires three. This is how to close that gap.

Source: https://www.thedesignagent.ai/field-notes/the-eight-field-form · Anti-patterns · 2026-05-06

Give an agent a schema with twelve columns and ask it to build an intake form. You'll get twelve fields. Sometimes thirteen — agents like to add a notes field on principle. The form maps directly to the model: every column that accepts user input becomes a form field, laid out in the order the columns appear in the schema.

This is the eight-field form problem. Not literally eight — the number is whatever the schema happens to have. The problem is the mapping logic: form fields are derived from database columns instead of from what the user needs to supply right now.

## A database field is not the same as a form field

A database column is a slot for data. A form field is a prompt for a human to supply something. These overlap, but they're not the same set.

Some columns should be defaults. The agent creating a record probably knows the user's organization, the current date, and a handful of status values that don't need human input at creation time. Some columns are derived — calculated from other values and should never appear in a form. Some columns are only relevant at a later stage of the record's lifecycle: fields that matter when closing a deal don't belong in the form for opening one.

When agents skip this analysis, every column becomes a form field. The user is asked to fill in values the system already knows, values that won't be needed until much later, and values that don't meaningfully change between records. Most of them get left blank or receive a default typed by habit. The form is noise with a few signal fields buried in it.

> **Pattern:** a form should collect the minimum set of inputs the job requires at this moment. Everything the system can derive, default, or collect later is overhead — and overhead in a form creates abandonment.

## The minimum viable form

For any given job, there's a minimum set of fields the user actually needs to supply. Finding it requires knowing the job: what decision does this form enable? What does the user need to input for that decision to be sound? What can wait?

A reorder request might need three fields at creation — item, quantity, urgency — and fifteen fields at approval. Building both as the same form is the wrong answer. The creation form should be three fields. The approval form should surface the additional context in read-only display, with only the fields that require input at the approval stage made editable.

This is progressive disclosure: show the fields the current stage needs, reveal the rest when they're relevant. Not as a UX trick but as an accurate model of how work actually unfolds.

## Why agents build the opposite

Agents don't have a concept of stage. They see a schema, a task, and a user. They build the form that would let the user fill in everything the schema accepts. This isn't wrong as far as it goes — the form is complete. But complete and useful aren't the same thing.

The deeper issue is that agents optimise for correctness of data capture rather than reduction of cognitive cost to the user. A form that collects everything needed to fully define a record is correct. A form that asks the user to supply only what they know right now and leaves the rest for later is better — but it requires knowing what "right now" means for this stage of this job.

## How TheDesignAgent flags it

On the `/ux` lens, a form with more fields than the active job requires at its current stage triggers a `extraneous_load` flag. The patch is specific: identify the minimum set for the current stage, move the rest to a secondary panel, detail view, or later-stage form. The agent receives the field names to remove from the primary form, not a general instruction to simplify.

The score on `jtbd_alignment` drops when the form is shaped like the data model rather than the job. That pairing — high extraneous load plus low JTBD alignment — is the signature of the eight-field form. Both sub-scores have to move for the patch to be considered applied.
