Harry Tandy

AI Researcher | Exploring Agentic Workflows | Follow for daily AI insights

[Harry Tandy @HarryTandy]

AI AGENTS AREN’T “WRITE ME A POST” ANYMORE

The mistake most people make: they spin up one bot and expect it to act as strategist, builder, tester, and editor at the same time

It falls apart fast

I broke down a real 4-agent workflow

Here are the 12 parts worth stealing

1. A single agent pollutes its own context fast. Planning, code, tests, fixes, explanations - all dumped into the same thread. By message 30, it’s fighting a task it misunderstood at message 3

2. Agent teams work better when every agent has one job. Planner thinks. Coder builds. Tester tries to break it. Reviewer decides if it ships

3. The key is the handoff file. Not vibes. Not “the next agent gets the idea.” A real file: spec.md, changes.md, test-results.md, review.md. If the next agent has nothing concrete to read, the pipeline is dead

4. Planner should never touch code. Its job is to kill ambiguity. What files change. What edge cases matter. What repo patterns to copy

5. Coder should not “clean up nearby stuff.” It reads spec.md and builds exactly that. The second it starts being helpful, your tiny task becomes a 900-line PR

6. Tester doesn’t patch the code. It writes tests, runs them, and stops the pipeline when something breaks. Otherwise, you just created another coder with worse context

7. Reviewer should be read-only. Give it edit access and it will start covering up problems instead of calling them out

8. Green tests are worthless if the tests check the wrong thing. A real test breaks when the business logic breaks. Everything else is theater

9. The most expensive failure is a quiet one. “Completed successfully” while skipping 14% of records is worse than a failing test

10. Don’t start with 20 agents. Start with two: Planner -> Coder. Once that handoff works, add Tester. Then Reviewer

11. An AI team without rules becomes noise fast. Set hard limits: no nearby refactors, no invented requirements, no moving forward with open questions

12. Speed comes from discipline. Handoffs first. Tests second. Overnight runs third. Flip that order and you get chaos

What actually compounds:

> one rules file per repo
> short handoff docs
> a checkpoint after every stage
> read-only review
> no “helpful” side quests
> a hard stop on ambiguity

AI agents don’t replace engineering discipline

They expose the lack of it faster than any human would

Save this if you’re building an actual pipeline, not just chatting with a bot

[darkzodchi @zodchiii]

https://t.co/YRF0PXhtk6

[Harry Tandy @HarryTandy]

@Flandermaxx mega-prompts always collapse under their own weight

[Harry Tandy @HarryTandy]

MOST PEOPLE USE AI LIKE A SLOW INTERN

They open one chat

Ask it to plan, build, research, write, debug, design, review, and package everything

Then they blame the model when the output collapses

The problem is the workflow

A single agent can be smart and still move in a straight line

That breaks the second your project has 40 tasks, 5 dependencies, 6 file types, and 100 sources to check

Here’s the setup worth stealing:

1. Give the strongest model the judgment work. Planning, dependency mapping, final QA, and hard decisions belong there

2. Give the swarm the repeatable work. Research, code files, charts, datasets, slide assets, and source collection can run in parallel

3. Start with a task tree, not a prompt. Every agent needs a clear job, expected output, and dependency

4. Separate the tracks before the run starts. Data, backend, frontend, assets, and review should never blur together

5. Mark hard dependencies. The backend should not build against a data schema that does not exist yet

6. Keep the planner out of the code. The planner creates the blueprint. The workers build from it

7. Make every sub-agent produce something checkable. A source list, a route file, a chart, a table, a slide, a test result

8. Parallel work still needs one final reviewer. Otherwise you get 300 fast outputs and no one checking whether they fit together

9. Multi-format output is where this gets useful. Code, deck, spreadsheet, PDF, and landing page can ship from the same run

10. Speed means nothing without traceability. Every number needs a source. Every file needs a purpose

11. The best workflow is simple: plan once, build in parallel, review hard, then ship

AI doesn't remove project structure

It makes structure more important

One agent can help you finish a task

A coordinated agent system can finish the whole package

[0xRicker @0xRicker]

https://t.co/yq1al85dxp

[Harry Tandy @HarryTandy]

@Long725792857 without a strict architecture, parallel AI just generates chaos faster

[Harry Tandy @HarryTandy]

@marfinxx most people collect knowledge instead of actually executing it

[Harry Tandy @HarryTandy]

@Blum_OG building a local, self-improving agent on your own hardware completely destroys the saas moat

[Harry Tandy @HarryTandy]

@alphabatcher mining past corrections automatically beats manual rule maintenance every single time.

[Harry Tandy @HarryTandy]

@kylethomasc managing that scale demands a strict custom orchestrator

[Harry Tandy @HarryTandy]

@Blum_OG proper setup now prevents weeks of endless debugging

[Harry Tandy @HarryTandy]

YOUR AI WORKFLOW IS BURNING MONEY IN THE WRONG PLACE

Most people put their strongest model on the dumbest part of the job

They ask one premium agent to research 50 companies, build a dataset, write a report, make a deck, check sources, and fix mistakes

Then they wonder why it gets slow, expensive, and messy

The better setup is simple:

> use judgment where judgment matters
> use parallel agents where volume matters

Here are the 10 rules worth stealing

1. The best model should write the brief, not do all the labor. A sharp spec saves more tokens than any prompt trick

2. One agent is fine for one hard decision. It gets worse when you ask it to hold 80 moving parts in one context window

3. Swarms win when the task can split cleanly. One company per agent. One source list per agent. One section per agent

4. Bad briefs create bad swarms. “Research the market” is vague. “Return company, funding, revenue, market share, and source URL” gives the agents rails

5. Parallel work needs a merge plan before it starts. Otherwise you get 20 decent outputs and one painful cleanup job

6. Every claim needs a clickable source. A fast report with weak sources is just expensive noise

7. Do not use a swarm for a tiny task. Running 100 agents on a one-file fix is how people confuse automation with waste

8. Route the work by brain level. Use the strongest model for the spec and final review. Use cheaper parallel agents for the bulk

9. The dashboard matters. You need to see which agent is searching, which one is writing, which one is waiting, and where the run is stuck

10. Final QA is not optional. Check that the deck matches the dataset, the numbers match the sources, and no agent overwrote another file

The setup that actually works:

> premium model writes the brief
> swarm produces the files
> premium model reviews the output
> human checks the claims that matter

That’s the difference between "I chatted with an AI" and "I built a production loop"

AI agents do not save you from structure

They punish you faster when you skip it

[darkzodchi @zodchiii]

https://t.co/X8rwhUmmyF

[Harry Tandy @HarryTandy]

@compileandpush Internal needs

I built what my workflow required

[Harry Tandy @HarryTandy]

@Blum_OG mixing heavy models and fast subagents drops API costs

[Harry Tandy @HarryTandy]

@alphabatcher most devs expect Claude to read their minds

[Harry Tandy @HarryTandy]

@alphabatcher a reliable production harness matters more than a smart model

[Harry Tandy @HarryTandy]

@JayBisen473370 nailing the mental model saves weeks of debugging

[Harry Tandy @HarryTandy]

MOST AI APPS BREAK BEFORE THE FIRST LINE OF CODE

Because the builder starts with implementation

Not with the mental model

Then the same problems show up:

> the chatbot hallucinates
> RAG pulls the wrong documents
> the model forgets key instructions
> the API bill grows for no clear reason
> the agent gets stuck after 4 steps

None of that is random

It usually means the builder skipped the concepts

Here are the 10 AI concepts worth learning first:

1. Tokens
This is what the model actually reads. Cost, speed, limits, and memory all come back to tokens

2. Embeddings
This is how meaning becomes searchable. Bad embeddings usually mean bad retrieval

3. Attention
This is how the model decides which parts of the context matter

4. Transformers
This is the architecture behind modern LLMs

5. LLMs
They predict the next token. They do not work like databases

6. Hallucination
The model can sound right while being completely wrong

7. Temperature
This controls how predictable or random the output gets

8. Context window
The model can only use what fits inside its working memory

9. RAG
This lets the model answer using your actual documents

10. Agents
An agent is a loop: plan, act, check, repeat

The mistake is learning these after the system breaks

The code gets much easier when you understand what the model is actually doing

[Rahul @sairahul1]

https://t.co/WN0MsLNjDw

[Harry Tandy @HarryTandy]

@nrqa__ pure theory breaks when you build real agents

[Harry Tandy @HarryTandy]

@0xRicker this is what agent workflows should actually look like

[Harry Tandy @HarryTandy]

@compileandpush when other founders asked to use my system

[Harry Tandy @HarryTandy]

@alphabatcher a solid agentic workflow beats standard prompting every time

[Harry Tandy @HarryTandy]

@rileywestreel a cluttered context window guarantees a broken agent

[Harry Tandy @HarryTandy]

AI AGENTS AREN’T “WRITE ME A POST” ANYMORE

The mistake most people make: they spin up one bot and expect it to act as strategist, builder, tester, and editor at the same time

It falls apart fast

I broke down a real 4-agent workflow

Here are the 12 parts worth stealing

1. A single agent pollutes its own context fast. Planning, code, tests, fixes, explanations - all dumped into the same thread. By message 30, it’s fighting a task it misunderstood at message 3

2. Agent teams work better when every agent has one job. Planner thinks. Coder builds. Tester tries to break it. Reviewer decides if it ships

3. The key is the handoff file. Not vibes. Not “the next agent gets the idea.” A real file: spec.md, changes.md, test-results.md, review.md. If the next agent has nothing concrete to read, the pipeline is dead

4. Planner should never touch code. Its job is to kill ambiguity. What files change. What edge cases matter. What repo patterns to copy

5. Coder should not “clean up nearby stuff.” It reads spec.md and builds exactly that. The second it starts being helpful, your tiny task becomes a 900-line PR

6. Tester doesn’t patch the code. It writes tests, runs them, and stops the pipeline when something breaks. Otherwise, you just created another coder with worse context

7. Reviewer should be read-only. Give it edit access and it will start covering up problems instead of calling them out

8. Green tests are worthless if the tests check the wrong thing. A real test breaks when the business logic breaks. Everything else is theater

9. The most expensive failure is a quiet one. “Completed successfully” while skipping 14% of records is worse than a failing test

10. Don’t start with 20 agents. Start with two: Planner -> Coder. Once that handoff works, add Tester. Then Reviewer

11. An AI team without rules becomes noise fast. Set hard limits: no nearby refactors, no invented requirements, no moving forward with open questions

12. Speed comes from discipline. Handoffs first. Tests second. Overnight runs third. Flip that order and you get chaos

What actually compounds:

> one rules file per repo
> short handoff docs
> a checkpoint after every stage
> read-only review
> no “helpful” side quests
> a hard stop on ambiguity

AI agents don’t replace engineering discipline

They expose the lack of it faster than any human would

Save this if you’re building an actual pipeline, not just chatting with a bot

[darkzodchi @zodchiii]

https://t.co/YRF0PXhtk6

[Harry Tandy @HarryTandy]

@zodchiii this is the workflow most builders skip

thanks for sharing