# Capture First workflow

Version: 1.0.1

The goal is simple: press one button, speak, stop, and know whether the thought reached Airtable.

The capture path does one job. It preserves what you said. Any cleanup, summary, classification, or AI analysis happens later.

> Capture first. Enrich second. Analyze later.

## The flow

```text
iPhone Action Button
        ↓
Capture Thought Shortcut
        ↓
Apple dictation
        ↓
Blank-text check
        ↓
POST Raw Thought + New status to Airtable
        ↓
Check records[0].id
        ↓
Show Thought saved only when an ID exists
```

## What you'll build

- An Airtable table that keeps the raw thought and capture time.
- A base-scoped Airtable token with record-write access.
- An Apple Shortcut named `Capture Thought`.
- A response check that separates a confirmed save from a failed or uncertain one.
- An Action Button trigger after the manual test passes.

## 1. Build the Airtable table

Create a base and a table for your thoughts. Use the exact field names and choices in `airtable-schema.md`.

The Shortcut writes only two values during capture:

- `Raw Thought`: the dictated text.
- `Processing Status`: `New`.

`Captured At` is automatic. `Core Idea`, `Type`, and `Attachments` stay empty unless you use them later.

## 2. Create the token

Create an Airtable Personal Access Token for this capture path.

Give it only:

- record-write access
- access to the one base used for capture

Copy the complete token when Airtable shows it. Store it inside the Shortcut header. Don't put it in a note, screenshot, repository, or issue.

## 3. Build the Shortcut

Open `shortcut-action-map.md` and add the actions in order.

Your endpoint will look like this:

```text
https://api.airtable.com/v0/YOUR_AIRTABLE_BASE_ID/YOUR_TABLE_ID
```

Your two request headers are:

```text
Authorization: Bearer YOUR_AIRTABLE_TOKEN
Content-Type: application/json
```

Build the request body with Shortcuts' Array and Dictionary controls. Don't type the braces as plain text.

## 4. Run the connection test

Before you add the final response check, place a temporary `Show Result` action after `Get Contents of URL`.

Dictate a harmless test sentence. A successful Airtable response should contain a `records` list and a created record ID that begins with `rec`.

Open Airtable and check the new row:

- `Raw Thought` matches the dictation.
- `Processing Status` is `New`.
- `Captured At` has a value.
- `Core Idea` and `Type` are blank.

Delete the temporary test row if you don't need it. Remove `Show Result` before you build the final response check.

## 5. Confirm the save

The Shortcut reads:

```text
records → first item → id → text
```

It shows `Thought saved` only when that text has a value.

If Airtable doesn't return an ID, show an alert named `Thought not confirmed`. A network or API error may stop the Shortcut before the alert runs. Either result means the save wasn't confirmed.

## 6. Run the manual acceptance test

Run the finished Shortcut inside the Shortcuts app before assigning the Action Button.

Check all of these:

- Dictation opens.
- A valid sentence creates one Airtable row.
- The saved raw text matches what the phone transcribed.
- The row starts with `Processing Status` set to `New`.
- `Captured At` is automatic.
- `Thought saved` appears only after Airtable returns a record ID.
- A failed or uncertain request doesn't show success.
- Empty dictation exits without creating a row.

That last check is especially important because it was designed into Paul's V1 but wasn't marked independently verified in the source acceptance record.

## 7. Assign the Action Button

After the manual test passes:

1. Open iPhone Settings.
2. Open Action Button.
3. Choose Shortcut.
4. Select `Capture Thought`.
5. Press and hold the Action Button for one final test.

The finished experience should be:

```text
Press → speak → tap Done → confirmed save
```

## 8. Use it before expanding it

Capture five to ten real thoughts over at least one day. Watch for missed saves, duplicate retries, bad transcription, or anything that makes you hesitate before pressing the button.

Leave AI out of the capture path. If you later add summaries or Types, use a separate process and never overwrite `Raw Thought`.

## Manual records and attachments

You can also create a record directly in Airtable. Add an explanatory `Raw Thought`, set the status to `New`, and attach screenshots, photos, or documents when they help preserve the source.

Attachments support the written thought. They don't replace it.