Through Time

Working with a machine: from a request to an agent

How to set a machine a task, hand it real work, limit what it may touch and check the result, even if you have never programmed.

A course for people who have tried chatbots and want work from them, not text that resembles work. You will learn to set a task, give context and examples, decide what can be handed over, limit what an agent may do and check what it did. The course “AI: from symbols to agents” explains what is inside a model; this one is about the craft, and it takes no programming.

So far there is only this table of contents. Lessons appear one at a time, and we promise no dates. Feed of new lessons (Atom)

18 lessons, 4 parts

Part 1 A good request

A request to a machine works like a brief to a person: the more exact the task, the less the model fills in for you.

  1. A brief, not a question

    Who it is for, what should come out and how you will know it is right: without these, the model decides for you.

    coming soon

  2. What the machine does not know about you

    A model sees only what you gave it: which documents and circumstances to attach, and which only get in the way.

    coming soon

  3. Show it, do not describe it

    One good sample and one bad often explain a format better than a paragraph of instructions, though a model may copy their accidental traits too.

    coming soon

  4. Standing instructions

    Project settings and a rules file: what is worth writing down once, and why an overlong rulebook stops working.

    coming soon

  5. What to do with a bad answer

    Refine it, start over or change the approach: how to tell that a conversation has hit a dead end and is only piling up mistakes.

    coming soon

Part 2 What to hand over

The main decision comes before the first prompt: whether this work should go to a machine at all, and in what pieces.

  1. The jagged frontier

    Where a model clearly helps, where it quietly lets you down, and how to find that jagged line in your own work.

    coming soon

  2. Hand over what you can check

    A working rule: a task fits if judging the result costs less than doing it yourself, and you know what an unnoticed mistake would cost.

    coming soon

  3. Cutting a big job into pieces

    How to divide work into steps with intermediate results, so that a mistake surfaces at step two, not in the finished report.

    coming soon

Part 3 A machine that acts

An agent does not answer, it acts: it gets permissions, and those are your responsibility.

  1. Briefing an agent

    What to add to an ordinary request when the worker will take a hundred steps without you: a definition of done, the limits, and when to stop and ask.

    coming soon

  2. What permissions to give

    Reading, writing, sending, paying: how to grant an agent the minimum, keep a copy, and decide in advance what it will not touch.

    coming soon

  3. Someone else’s orders in your inbox

    An email or a web page can give orders to your assistant: what prompt injection looks like from the user’s side, and what to do about it.

    coming soon

  4. Three kinds of access that do not mix

    Private data, untrusted content and a way to send things out: the mix Simon Willison named the lethal trifecta, and what to remove if you have built it.

    coming soon

Part 4 Checking and supervising

Work is done when you have seen it yourself, not when the machine says so.

  1. A report is not proof

    A model will confidently write “all done” about work it did not do, so ask for what you can see yourself: a file, a link, a result on a known case.

    coming soon

  2. How to review work you did not do

    Spot checks, test cases and a second model as a reviewer: how to spend your attention when you cannot read everything.

    coming soon

  3. A written workflow: noetic-harness

    NoeticEcho’s open project holds agents to written workflows and refuses a step with no evidence: what to carry over even if you write no code.

    coming soon

  4. One person, many agents: control-room

    What changes when there are several workers: conflicts over the same files, and your attention as the narrowest point, seen in an open project.

    coming soon

  5. What an agent should remember

    Notes, rules files and libraries such as Reminisce: what to write down for next time, and how a stale note turns into a mistake.

    coming soon

  6. A look ahead: from tasks to oversight

    If agents keep working longer without a person watching, which skills gain value, and how to tell what is real from what is only promised.

    coming soon