Skip to content
Hoegun You
Go back

How to start in two weeks

A small team walking up a path of steps toward a flag, with a robot alongside

If you’ve read this far, the obvious question is where to start.

Not with a tool comparison. Every tool I mention in this series will look different in six months. Start with a habit: one real piece of work handed to an AI every day, and a short note about what happened. Everything else in this series grew from that.

This is the last part of a series on what I learned putting AI agents to work in my own job. The first seven parts are the evidence; this one is the plan. It’s the same plan I wrote down for others, as a ten-chapter internal guide, after doing it myself.

Why two weeks is enough to start

Two weeks won’t transform anything. It’s enough to find out which of your tasks an AI does well, to set up one folder an agent can work in, and to write down the first rules. That’s the foundation every later step stands on.

For a sense of what becomes possible once that foundation exists, three examples from my own work, each with the detail in its own episode:

  • A documentation hub of 63 documents in one day (part 5).
  • A team agent with two helpers behind it, built in three days (part 6).
  • Reminders that carry the check, designed, tested and moved over in one day (part 7).

None of that was the first step. My first step was web chat, in October 2025. The later steps, from local agents to handing off routines, took under three months once I committed in September 2026 (part 1).

Five steps, and when to take the next

Five steps, and when to take the next: web chat, saved instructions and files, a local agent in a folder, a shared team agent, recurring work handed off

You don’t have to take these in order, but each one makes the next easier. The “next step when” signals are goals I’d aim for, not measurements; your timing will differ.

  1. Web chat. Use a chat assistant for one real task a day: a first draft, a summary of a long thread, a translation, a second reading of something before it goes out. Next step when drafting with AI first feels normal, and you notice you keep pasting the same background.
  2. Saved instructions and files. Most assistants let you keep a project: standing instructions (“tone, things never to promise, how to sign off”) plus the reference documents you always need. Next step when new chats start without explanation, and the work starts spanning many files or you want results as files, not chat replies.
  3. A local agent in a folder. An agent that reads and writes files in one folder, set to ask before it edits. One folder per job: originals it never edits, references, results, and a short rules file it reads first (part 4). Next step when other people repeatedly need answers you can support with written context, and your team agrees on the agent’s scope and access.
  4. A shared team agent. An agent other people can ask, in the place they already work. Keep it narrow, make it say how sure it is, and give it the written context first (parts 5 and 6). This step is usually a team decision, not a personal one. Next step when a recurring check has explicit rules, a clear owner, and a way to detect when it fails.
  5. Recurring work handed off. The checks you run every week become code that decides and a model that explains (part 2); the “check this again next week” notes become reminders that carry the exact check (part 7). After this, each new job starts again at step 3.

A two-week plan

A two-week plan: week 1 to get used to it, week 2 to go one step further

Week 1: get used to it

  • Day one, read the rules first. Decide what you will never paste into any AI tool (personal data, credentials, anything you’d regret seeing outside the company) and what you check before anything AI-written leaves your hands. Part 3 has mine.
  • Every day, one real task. Not a toy question. Something you’d have done anyway: an email, a summary, a review. Keep the result only after you’ve checked the facts in it.
  • Once, the same request in two assistants. Compare the answers. You’ll learn more about both tools, and about your request, than from either one alone.
  • Once, ask for sources. Add “show me which part of the material you used, and say ‘not in the material’ when it isn’t there.” Watch how much easier it is to check.
  • On Friday, list three recurring tasks you could hand off. Good candidates repeat on a schedule, gather material from several places, need a first draft, or are things you’ve always wanted to do and never had time for.

Week 2: one step further

  • Make one project with standing instructions and two or three reference files for a job you do often.
  • Set up a practice folder with files that hold nothing sensitive. Ask a local agent to summarise them into a new file. Start with a read-only plan. Before it executes, choose a mode that asks before edits and check that it’s set; approving the plan isn’t approval for every later action. Approve only what you can explain in your own words.
  • Write a rules file for that folder. Every time the agent makes a mistake, fix it, then ask it to add one line so it doesn’t happen again. That file becomes the know-how for the job.
  • Do one of your three tasks with the agent. End the session by asking it to write what it did, what it learned, and the first request to use next time (part 5).
  • Share one thing that worked and one that didn’t with your team.

Share what works

Writing things down paid off for me before it paid off for anyone else. The records behind this series, design notes, a timeline and a lessons file, are why I could quote numbers instead of impressions. When the machine my agents run on had to be rebuilt, the agents and supporting services were back in about a day; one monitor’s history was lost (part 5).

What’s worth sharing with a team:

Share Why
A request that worked, with the result Others can reuse it as is
A rules file, with nothing secret in it The know-how for a job, in one page
A before and after for one task Shows where the time actually went
A failure, and what fixed it Saves everyone else the same afternoon
A question (“could AI do this?”) Often someone already tried

Keep it short: what you did, how you asked, and what happened, in three lines. When something works for everyone, move it from the chat into the team’s documentation, so the next person, and the next agent, starts from it.

Questions people ask

Will this take my job? My view: it takes the parts of the job that were finding, copying and chasing, and moves people towards judgment, review and relationships with customers and partners. That’s where my own time went (part 1). And I believe the people who use it well will end up with bigger jobs, not smaller ones.

I’m not technical. Can I still do this? Yes. Ask in plain language, and when an answer doesn’t make sense, say “explain that as if I’m not a developer.” Local agents now start from desktop apps; you don’t need a terminal to begin. The one rule that matters most: never approve an action you can’t explain in your own words. Refuse and ask what it does.

What if it’s wrong? It will be, sometimes, confidently. That’s why a person checks numbers, dates, policies and promises against the source before anything leaves their hands, and why anything that must be right the same way every time belongs in code or a formula, not in a model’s answer (parts 2 and 3). When it’s wrong, correct it, then turn the correction into a rule.

Which tool should I use? Try two for a week and keep the one that fits your work. For local agents, learn one well before adding another.

I don’t have time to learn this. That’s why the plan is one task a day. Keep the first task small enough to fit in a few minutes, and allow extra time for setup and checking. What you get back depends on which tasks you hand off, which is what the Friday list is for.

If I started again

Three things from the records, not from hindsight:

  • Write the context before building the agent. Agents without written context kept rediscovering the same things; the documentation hub is what made everything after it work (parts 4 and 5).
  • Keep decisions in code. A model should explain a result, not decide whether something is wrong (part 2).
  • Enforce rules outside the prompt. When an agent ignored a written rule and burned through the API credit, the fix was to take the tool away, not to write the rule more firmly (part 3).

That’s the series. Start with one task tomorrow, and a note about what happened.

The series

  1. From doing the work to delegating it
  2. Let code decide, let the LLM explain
  3. The rules I never break
  4. Context is the job
  5. Agents forget, so I write it down
  6. kenny: an agent that does my job
  7. Hermes: reminders that carry the check
  8. How to start in two weeks (this post)

What’s the one recurring task you’ll hand to an agent first, and what will you write down before you do?



Previous Post
Hermes: reminders that carry the check