# AI use cases for Bloks (hamedgitty/bloks)

Repo: [hamedgitty/bloks](https://github.com/hamedgitty/bloks) | Use cases: 5 | Page: https://dedupedai.com/use-cases/hamedgitty-bloks/

Bloks is a local-first desktop workspace where you run personal AI agents on your own machine, with their conversations, memory and approvals kept on that machine.

This file holds every use case of this repo. Each one starts with a "## " heading and ends with its URL.

- Keep a coding agent working until tests pass: https://dedupedai.com/use-cases/hamedgitty-bloks/keep-coding-agent-until-tests-pass/
- Rehearse a risky file change before it touches your folder: https://dedupedai.com/use-cases/hamedgitty-bloks/rehearse-file-changes-before-applying/
- File incoming documents from a folder automatically: https://dedupedai.com/use-cases/hamedgitty-bloks/file-incoming-documents-with-a-watcher/
- Read what your agents did overnight in one brief: https://dedupedai.com/use-cases/hamedgitty-bloks/read-overnight-agent-work-each-morning/
- Back up your whole agent workspace and restore it: https://dedupedai.com/use-cases/hamedgitty-bloks/back-up-and-restore-agent-workspace/

## How to keep a coding agent working until tests pass with Bloks

Repo: [hamedgitty/bloks](https://github.com/hamedgitty/bloks) | Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Give an agent a goal and a check command, and let it loop turn by turn until the check passes.

**Who it is for:** A developer with a project that has a test suite, who wants a coding agent to finish a fix without typing keep going after every turn.

**The problem:** A coding agent usually stops after one turn, so you have to keep prompting it until the tests pass.

**The outcome:** The agent keeps working turn after turn and counts the task as done only when the check passes, with a chip above the composer showing the current turn.

### Steps

1. Open the agent's conversation in Bloks and pick the project folder it works in.
2. Type /goal in the message box and describe what done looks like, for example: all tests in the project pass.
3. Add the check to the goal: pnpm test
4. Watch the turn chip above the composer; use Pause if you want to stop the loop.
5. When the goal ends, review the change card under the last reply and use the undo button if the result is wrong.

### Prompt to paste into your agent

```text
Using the Bloks repo at hamedgitty/bloks, start a /goal in the agent conversation for the project at <project-folder>, with the check pnpm test. Expected output: the goal reports done, stuck or out of turns, and the test run result. Verify that pnpm test passes in <project-folder> before you call the goal done.
```

### Caveat

The README does not say how many turns a goal allows beyond stopping when done, stuck or out of turns, so check the goal status on screen rather than assuming a fixed limit.

Risk, remote script: A goal loop runs commands in your project folder on its own, so set your approval level and rules before you start it, and avoid Full access for unattended loops.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/hamedgitty-bloks/keep-coding-agent-until-tests-pass/

## How to rehearse a risky file change before it touches your folder with Bloks

Repo: [hamedgitty/bloks](https://github.com/hamedgitty/bloks) | Difficulty: Intermediate | Time: 15 minutes | Basis: From the README

Let an agent do a task on a copy of your folder, compare attempts, and apply only the one you want.

**Who it is for:** A person who wants an agent to reorganise or edit files in a working folder but does not want the first attempt to land in the real folder.

**The problem:** An agent that edits the real folder directly can leave changes you did not expect, and sorting them out afterwards is slow.

**The outcome:** You see the changes as a card with Apply and Discard, and applying writes only files you have not changed since the rehearsal started.

### Steps

1. Describe the task to the agent in the message box, such as renaming and sorting the files in a folder.
2. Press the flask beside the microphone so the agent works on an instant copy of its folder.
3. Pick other agents in the same bar if you want them to rehearse the same task on their own copies.
4. Compare the attempts side by side in the Rehearsals panel and read each change card.
5. Press Apply on the attempt you want, or Discard to drop it; then undo from the card if needed.

### Prompt to paste into your agent

```text
Using the Bloks repo at hamedgitty/bloks, rehearse the task <task-description> on a copy of the folder <target-folder> with the agent in Bloks. Expected output: a change card listing each changed file with its line count and diff, with Apply and Discard buttons. Verify that the real folder <target-folder> is unchanged until you press Apply.
```

### Caveat

Rehearsals work on a copy of the folder, so anything the agent does outside that folder is not covered by the rehearsal.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/hamedgitty-bloks/rehearse-file-changes-before-applying/

## How to file incoming documents from a folder automatically with Bloks

Repo: [hamedgitty/bloks](https://github.com/hamedgitty/bloks) | Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Point an agent at a folder with a rule, so new files are handled the moment they land.

**Who it is for:** A freelancer or small business owner whose invoices and receipts arrive as files in one folder and need filing by hand each week.

**The problem:** Every new invoice or receipt has to be found and moved manually, which is easy to forget.

**The outcome:** A watcher on the folder runs your rule when a file lands, and the first look only sets a baseline so existing files are not handled.

### Steps

1. Open the agent you want to handle the files and tell it in plain words what to do, for example: when an invoice lands in this folder, file it.
2. Or ask the agent to keep an eye on the folder, and let it file the watcher itself.
3. Choose whether the watcher should rehearse on a copy first, so you can check its first actions.
4. Check the first runs in the conversation and the change card under each reply.
5. Adjust or remove the watcher in the agent's settings if the rule needs changing.

### Prompt to paste into your agent

```text
Using the Bloks repo at hamedgitty/bloks, set up a watcher on the folder <incoming-folder> that files new invoices into <filing-folder>. Expected output: a watcher entry plus a change card for each filed file. Verify that the first look only created a baseline and that the first real file was filed as your rule says.
```

### Caveat

The README says a folder is seen within seconds and a watcher fires at most six times an hour, so bursts of files will be handled over time rather than all at once.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/hamedgitty-bloks/file-incoming-documents-with-a-watcher/

## How to read what your agents did overnight in one brief with Bloks

Repo: [hamedgitty/bloks](https://github.com/hamedgitty/bloks) | Difficulty: Intermediate | Time: 15 minutes | Basis: From the README

Get a morning summary of agent work, pending approvals and daily cost, with links to each source.

**Who it is for:** A person who runs several agents in the background and wants a quick start to the day without opening each conversation.

**The problem:** Agents work while you are away, and finding out what they did and what is waiting on you means opening every conversation.

**The outcome:** Each morning Bloks writes a brief from what is on disk, where every line links to its source, and approvals can be answered from it.

### Steps

1. Open Settings and check the time the morning brief runs; the default is 08:00.
2. Set up one or more agents with routines or check-ins so there is work to report.
3. Open the morning brief when it appears and read what each agent did while you were away.
4. Answer any approval listed in the brief directly from it.
5. Use Play to hear each agent give its own part of the brief, or follow a line link to its source.

### Prompt to paste into your agent

```text
Using the Bloks repo at hamedgitty/bloks, enable the morning brief and run one routine for the agent <agent-name>. Expected output: a morning brief listing what <agent-name> did, what is waiting on you and the day's cost, with a link for each line. Verify that each line links to a real conversation or file.
```

### Caveat

The brief is built from what is already on disk rather than by a model, so it only reports what the agents already recorded.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/hamedgitty-bloks/read-overnight-agent-work-each-morning/

## How to back up your whole agent workspace and restore it with Bloks

Repo: [hamedgitty/bloks](https://github.com/hamedgitty/bloks) | Difficulty: Intermediate | Time: 15 minutes | Basis: From the README

Seal a backup with a passphrase, check it, and restore it without losing what it replaces.

**Who it is for:** A person who has built up agent memory, skills and conversations in Bloks and wants a safe copy before moving to a new machine or reinstalling.

**The problem:** Losing a workspace loses memory, conversations and setup that took time to build.

**The outcome:** A passphrase-sealed backup you can check and restore, with a fresh backup taken first so the replaced data is kept.

### Steps

1. Open Settings and find Backups; the whole workspace is backed up every day, and you can back up any time.
2. Start a backup, seal it with a passphrase, and store the passphrase somewhere safe.
3. Check the backup from Settings to confirm it is readable.
4. To restore, use Settings or run: bloks-server restore
5. Confirm the restored agents, conversations and memory look right; the restore keeps a fresh backup of what it replaces.

### Prompt to paste into your agent

```text
Using the Bloks repo at hamedgitty/bloks, create a sealed backup of the workspace and check it. Expected output: a backup file that the check reports as valid. Verify that the check passes and that you have the passphrase stored outside the backup.
```

### Caveat

The README says the restore command is bloks-server restore, but it does not describe where backup files are stored, so check the Backups section in Settings for the location.

Risk, credentials: Keys only go into a sealed backup, so losing the passphrase means losing access to those keys, and an unsealed copy should never be stored.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/hamedgitty-bloks/back-up-and-restore-agent-workspace/
