# The Robots Are Coming for Your Job, and That's Okay

Elmer Thomas & Maria Bermudez, Twilio | AI Engineer World's Fair 2025 | 08:57

Source: https://www.youtube.com/watch?v=pSqpC7fFLZA
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/the-robots-are-coming-for-your-job-and-thats-okay
Published: 2025-06-03
Tags: agents, guardrails, human-in-the-loop, workflows

## TL;DR
- Twilio's small Developer Education team uses six focused AI agents to handle repetitive documentation work instead of deploying one autonomous documentation bot.
- The agents apply Twilio's style guide and rubric, then pass through validation, linting, CI tests, code-owner review, and human approval before a merge.
- The team recommends starting with one high-volume, repeatable, rule-based task and reviewing results with users every week.

## Summary
Elmer Thomas and Maria Bermudez explain how Twilio's small documentation team uses AI agents to handle repetitive work from more than 100 product teams. Their system has six focused agents for editing, alt text, jargon simplification, SEO metadata, documentation outlines, and Slack request triage. Each agent has a narrow task and uses a style guide and rubric retrieved from Airtable. Generated changes pass through validation, Veil Lint, CI tests, GitHub code-owner review, and human approval. Maria demonstrates agents that edit a live URL, generate SEO metadata, create alt text for multiple pages, and simplify technical language. The team accepts that the tools are imperfect, including missed SEO descriptions, so weekly reviews and feedback from product and engineering teams are part of the process. Their advice is to start with one repetitive task, measure it, and refine it with users.

## Key ideas
### A small documentation team has more repetitive work than it can handle manually
[00:53](https://www.youtube.com/watch?v=pSqpC7fFLZA&t=53s)
Thomas describes a tiny docs team facing a flood of Jira tickets and error-prone first drafts from more than 100 product teams. Routine work includes style checks, alt text, and SEO tasks. The team wanted to increase its capacity without burning out, so it chose to automate narrow jobs rather than build one general-purpose bot. Thomas says the best candidates are tasks that are repeatable, high volume, and low creativity. That leaves people with more time for judgment and clarity.

### Six focused agents divide the documentation workload
[01:17](https://www.youtube.com/watch?v=pSqpC7fFLZA&t=77s)
Twilio built six single-purpose agents behind a simple Next.js frontend. The automated editor handles grammar, formatting, and accuracy. The image alt text generator creates accessibility text, while the jargon simplifier turns developer language into plain English. The SEO metadata agent creates titles and descriptions within character limits. A documentation outline builder recommends navigation and structure, although Thomas says it is still coming soon. A Slack bot helps triage help-channel requests. Each tool has one well-scoped responsibility.

### The agents use shared guidance and job-specific models
[02:37](https://www.youtube.com/watch?v=pSqpC7fFLZA&t=157s)
Every request starts in a Next.js user interface and goes to a custom GPT-4o agent, with the appropriate model selected for the job. The custom GPT includes Twilio's style guide and rubric. That rubric is retrieved from Airtable, which lets people collaborate on it. The system therefore gives the model explicit documentation rules rather than relying only on general model behavior. Maria later explains that the team experimented with the o1 model for the automated editor and found it consistently applied their style guide and rubric.

### Generated changes go through several checks before a merge
[03:02](https://www.youtube.com/watch?v=pSqpC7fFLZA&t=182s)
The workflow includes a validation layer with Veil Lint and CI/CD tests. A GitHub pull request adds code-owner review, making the agent's suggested changes easier to inspect. A human merges only when the change is correct, and product and engineering reviews often add more scrutiny. Thomas initially says the layered approach crushes hallucinations, then corrects himself: it reduces them significantly. The process keeps automation away from direct customer-facing publishing.

### The editor explains each change instead of returning only rewritten text
[03:53](https://www.youtube.com/watch?v=pSqpC7fFLZA&t=233s)
Maria demonstrates the automated editor with a live URL. The interface shows a diff and a changes-made tab. That tab explains the original text, revised text, and the style guidance or rubric item connected to each change. Maria also points out a limitation: the editor sometimes detects a missing SEO description and sometimes does not. That gap is why the team has a separate SEO metadata generator rather than assuming one agent will catch every documentation issue.

### The demo covers metadata, accessibility text, and plain-language editing
[05:00](https://www.youtube.com/watch?v=pSqpC7fFLZA&t=300s)
The SEO agent generates a meta title and a meta description while accounting for character limits. The alt text agent can accept multiple pages and generate text for all their images in the format required by Twilio's documentation platform. The jargon simplifier accepts prepared text and returns revised wording in an editor-like view. Maria says the simplifier helps with writing and with pull request reviews, where its output can become a quick review comment or be applied directly to the file.

### Human feedback is part of the system's quality controls
[07:21](https://www.youtube.com/watch?v=pSqpC7fFLZA&t=441s)
Thomas groups the remaining risks into hallucinations, bias, and stakeholder misalignment. Veil Lint, CI tests, and reviews from human stakeholders help with hallucinations. Dataset tests and prompt audits address bias. Weekly pull request reviews and Slack feedback loops with product managers and engineers address alignment. These reviews can be compressed from weeks into days or hours. The feedback lets the team tune prompts continuously instead of assuming the model will stay correct on its own.

### The team recommends starting with one narrow workflow
[08:14](https://www.youtube.com/watch?v=pSqpC7fFLZA&t=494s)
Thomas gives a three-step playbook. First, identify one pain that is reducing throughput. Second, choose a single repeatable, rule-based task. Third, work with users at least weekly. The team should ship, measure, and refine the result. Thomas also says Twilio is working toward agents that can communicate with one another, but Maria's demo makes clear that the current tools remain separate and require more work before they can coordinate.

## Notable quotes
- "Rule of thumb, pick tasks that are repeatable, high volume, and low creativity." (02:07)
- "A human hits the merge only when it's right." (03:03)
- "It's not perfect as you can see, like sometimes it catches that there's a missing SEO description but other times it doesn't." (04:38)
- "Identify one pain that's killing throughput. Two, pick a single task that's repeatable and rule-based. And then three, loop with your users weekly at least." (08:14)

## Tools & references mentioned
- Twilio
- AI Engineer World's Fair
- Jira
- Next.js
- GPT-4o
- Airtable
- Veil Lint
- GitHub
- Copilot
- Slack
- Carly Vanderwart

## Who should watch
- Documentation teams supporting many product managers or engineering groups with limited staff will find concrete places to apply narrow agents.
- Teams considering autonomous documentation publishing should study Twilio's review, testing, and approval steps before allowing generated changes to reach customers.
- Engineers building internal AI tools can use the demo's pattern of focused agents, shared guidance, diffs, and user feedback.

## Related talks

- [Building AI Agents that Actually Automate Knowledge Work](https://aietalks.com/talks/building-ai-agents-that-actually-automate-knowledge-work) (Jerry Liu, LlamaIndex, 17:57)
- [Agents for Everything Else](https://aietalks.com/talks/agents-for-everything-else) (swyx, AI Engineer, 14:10)
- [Beyond Conversation: Why Documents Transform Natural Language into Code](https://aietalks.com/talks/beyond-conversation-why-documents-transform-natural-language-into-code) (Filip Kozera, Wordware, 10:57)
- [Software Development Agents: What Works and What Doesn't](https://aietalks.com/talks/software-development-agents-what-works-and-what-doesnt) (Robert Brennan, OpenHands, 16:46)
- [Platforms for Humans and Machines: Engineering for the Age of Agents](https://aietalks.com/talks/platforms-for-humans-and-machines-engineering-for-the-age-of-agents) (Juan Herreros Elorza, Banking Circle, 21:15)