[NFBCS] 6 Agents on Friday. 47 by Monday

[Ty Littlefield]

Sorry for the double email, but on thinking about this a bit more, I 
want to push back harder against this narrative.


I spend a lot of my time in the accessibility field. I work with people 
every day to help products become more accessible, and a lot of that 
work is nuanced discussion about design patterns, UX, and how to make 
everything functional regardless of ability.


I strongly believe that we should be using AI to make our lives better. 
It solves a lot of needs, and to outright ignore it is not the way to go.


That said, executives are trying to replace people like me. These are 
execs in companies who never have and never will use a screen reader. 
When putting out this type of content, I firmly believe that it does the 
entire community a disservice to suggest that exponentially increasing 
the number of agents somehow magically makes content more accessible and 
usable.


This reality is pretty obvious by going to the linked page, where there 
are a plethora of WCAG issues including the region label I mentioned in 
my prior email, regions being created where there should be none, and 
most notably a grid used for displaying information visually about the 
stats that is converted into one long line and not provided the proper 
aria roles to either display it as a table, or otherwise convert the 
information to a format that it can be more easily read.


If we're going to make claims that x agents solves accessibility 
concerns, they fall down rather quickly when a vibe coded page 
demonstrates most of the issues that professionals in this field often 
warn against and are fighting to solve every day.

Thanks,

*Ty Littlefield (he/him/his)*

  * From Bytes to Bites <https://tysdomain.com>|
  * Linkedin <https://www.linkedin.com/in/ty-lerlittlefield/>|
  * Github <https://github.com/tlfdev>

On 2/25/2026 12:50 PM, Jeff Bishop via NFBCS wrote:
> 6 Agents on Friday. 47 by Monday
>
> Hello NFBCS Members,
>
> Taylor and I are so excited about what this project has turned out to 
> be … Visit the community site on Github, learn about the GIT Going 
> with Github course that is happening on March 7^th and 8^th and get 
> involved. We would love your input, engagement and most importantly 
> your contributions.
>
> Jeff Bishop
>
> It is early Wednesday morning. February 26th. Something went so right 
> over the past five days that my brain will not stop replaying it.
>
> Let me take you back to Friday night.
>
> How a Frustrated Friday Night Became a Movement
>
> Friday Night on Discord
>
> I was working on a project. I do not even remember what it was. 
> Something with Claude Code, like most of my nights. And I was on a 
> Discord call with some friends, just talking while I worked.
>
> Then something happened in the code that just set me off.
>
> ARIA roles placed wherever the model felt like putting them. No logic. 
> No structure. Just ARIA sprayed across the page like decoration. 
> Inputs without labels. Modals with no focus trapping. Divs pretending 
> to be buttons. The same failures I have been correcting for months. 
> Every single session.
>
> I had enough.
>
> I had enough of fixing ARIA by hand. I had enough of inaccessible code 
> shipping as the default. I had enough of correcting these AIs over and 
> over and getting the same broken output the next time I asked. You 
> know the feeling. It is too much. At some point you stop asking nicely 
> and you start building.
>
> So that is what I did. I decided to build a team of AI agents. Not one 
> model trying to remember everything. A team. Specialists. Each one 
> responsible for one piece of accessibility that it cannot forget, 
> because that is the only thing it knows.
>
> I had no idea what I was getting into.
>
> I was just trying to solve a problem for myself. I wanted Claude to 
> actually write accessible code without me having to babysit every 
> line. That is it. I did not set out to build a forty-seven agent 
> system across three platforms with a GitHub organization and a website 
> and a press release. I was just frustrated on a Friday night.
>
> Of course, I tried other things first. I tried skills in Claude Code. 
> They activate maybe 10 percent of the time without manual 
> intervention. I tried writing detailed instructions in CLAUDE.md 
> files. They work at first, but as the conversation grows, they drift. 
> The model deprioritizes them. It decides other things matter more. 
> Accessibility gets quietly dropped from the plan. Every time.
>
> So, I built agents instead. Six of them. I published a preview post 
> that night, shared the repo, and went to bed.
>
> By Saturday morning, this thing had already outgrown what I imagined. 
> And it did not stop there.
>
> This Is Not Just Me
>
> I need to say this up front because it matters more than anything else 
> in this post.
>
> This is not my project anymore. It never should have been just mine. 
> The moment it stopped being one person yelling into the void and 
> became a team of people building together, everything changed. The 
> scope changed. The quality changed. The ambition changed. The whole 
> thing became something I could not have built alone. And that is the 
> point.
>
> Accessibility has always been a community fight. One person cannot 
> cover every screen reader, every browser, every framework, every 
> assistive technology, every lived experience. That is why the project 
> moved to a GitHub organization called Community Access. That is why it 
> is MIT licensed. That is why it costs nothing. Because the more people 
> who touch this, the better it gets for the people who need it.
>
> Jeff
>
> Jeff Bishop and I were talking on Friday night. That is how this 
> started. I was venting about AI tools forgetting accessibility, and 
> Jeff was right there with me. We were already in the same conversation 
> when I published the preview post and shared the repo.
>
> By Saturday morning, Jeff was not just talking anymore. He was 
> building. I did not expect what happened next.
>
> Jeff did not open an issue or send a message saying nice work. He 
> started pushing code. Within hours he was deep in the codebase, moving 
> faster than I could keep up. By the end of Saturday, he had more 
> commits than I did.
>
> That is not an exaggeration. Look at the git log. Forty-three commits 
> from Jeff in five days. He saw what I was trying to do. He saw where 
> it needed to go. And he went there.
>
> Jeff is blind. Like me, he uses assistive technology every day. He is 
> not reviewing accessibility as an abstract checklist. He is living it. 
> When he builds an agent that enforces focus trapping in modals, it is 
> because he has been trapped in modals. When he writes rules for screen 
> reader announcements, it is because he has sat in silence waiting for 
> an announcement that never came.
>
> That shared experience is what made this work. We did not have to 
> convince each other that accessibility matters. We just had to build.
>
> The Hooks Problem
>
> Now let me explain hooks, because if you read my preview post on 
> Friday, I made hooks sound like the answer to everything. They were not.
>
> A hook in Claude Code is a script that fires every time you send a 
> prompt. Think of it like a checkpoint. Before the AI starts working, 
> the hook looks at what you asked and decides if extra rules should 
> apply. If the task involves UI code, the accessibility agents 
> activate. If it does not, they stay out of the way. That was the idea. 
> And on Friday night, it worked.
>
> The problem arose when we tried to make hooks work for everyone. Not 
> just me on my Mac. Everyone. On every platform and different Claude 
> Code version.
>
> Hooks are fragile. They break across platforms. The JSON schema kept 
> changing. PowerShell on Windows handled them differently than bash on 
> Mac and Linux. Some hooks fired when they should not have. Others did 
> not fire when they should have. We spent hours debugging output 
> formats, timeout issues, and schema mismatches.
>
> Jeff and I merged pull requests fixing hooks. A pull request is how 
> you propose a change to code on GitHub. Someone reviews it, approves 
> it, and it gets merged into the main project. We merged pull requests 
> fixing hooks. Then more pull requests fixing the fixes. Then more 
> fixing those. It was a cycle. Every time we thought we had it, 
> something else broke.
>
> On Tuesday, Jeff made a decision I did not expect. He removed all of 
> them. Every hook. Every hook file. Every hook reference in every 
> documentation file. Gone.
>
> He replaced them with something better. Instead of hooks intercepting 
> prompts, orchestrator agents now coordinate the team through explicit 
> contracts. Each agent returns structured output with confidence levels 
> so the next agent knows exactly what it is getting. Nothing gets lost 
> between steps because the contracts define exactly what goes in and 
> what comes out.
>
> It is cleaner. It is more reliable. And it works on every platform 
> without platform-specific debugging.
>
> That is the kind of decision that only happens when someone is deep 
> enough in the code to see the real problem. Jeff was deep enough by 
> Saturday afternoon.
>
> What It Was
>
> On Friday, Accessibility Agents was six agents in a personal GitHub 
> repo under my name. An accessibility lead, an ARIA specialist, a modal 
> specialist, a contrast master, a keyboard navigator, and a live region 
> controller. It supported Claude Code. That was it.
>
> What It Is Now
>
> Forty-seven agents across four teams. Three platforms. Fourteen shared 
> knowledge modules. Fifty-two pre-built prompts. A GitHub organization. 
> A dedicated website. One command to install.
>
> The web accessibility team alone has sixteen agents. ARIA, modals, 
> contrast, keyboard navigation, live regions, forms, alt text and 
> headings, data tables, link text, cognitive accessibility, mobile 
> accessibility, design systems, guided audits, testing guidance, and 
> WCAG reference.
>
> There is a document scanning team that covers Word, Excel, PowerPoint, 
> PDF, and EPUB files. Forty-six built-in rules for Office documents. 
> Fifty-six for PDFs. It generates VPAT compliance reports. It exports 
> findings to CSV with links to help documentation so people know 
> exactly how to fix what it finds.
>
> There is a markdown documentation team that scans files across nine 
> accessibility domains.
>
> There is a GitHub workflow team with eleven agents for PR review, 
> issue triage, daily briefings, analytics, and repository management.
>
> It runs on Claude Code, GitHub Copilot, and Claude Desktop. It 
> installs with one command on macOS, Linux, and Windows. It is free. It 
> is MIT licensed. It costs nothing.
>
> Before Anyone Asks, No, This Is Not an Overlay
>
> I can already see the comment. Someone is going to read this post, see 
> forty-seven AI agents and the word accessibility in the same sentence, 
> and think: great, another magic fix. Another overlay. Another tool 
> that claims to solve accessibility so developers do not have to think 
> about it.
>
> No. Absolutely not. If you have read my writing before, you know how I 
> feel about overlays. One of them literally broke my rent portal so 
> badly that I could not pay rent until the landlord removed it. I have 
> written an entire post about why overlays are harmful. I am not about 
> to build one.
>
> Let me be crystal clear about what Accessibility Agents is and what it 
> is not.
>
> This is a developer tool. It runs inside your code editor while you 
> are writing code. It helps the AI write more accessible code from the 
> start. That is it. It does not touch your website. It does not add a 
> widget. It does not inject JavaScript into your pages. It does not 
> promise compliance. There is no toolbar. There is no badge. There is 
> no fee.
>
> And here is the part I really need you to hear. This does not replace 
> testing with real assistive technology. It does not replace VoiceOver. 
> It does not replace NVDA. It does not replace JAWS. It does not 
> replace a human being navigating your site with a keyboard and a 
> screen reader and telling you what is broken.
>
> What it does is raise the floor. Code that comes out of an AI tool 
> with these agents active is going to be more accessible than code that 
> comes out without them. Labels will be there. Focus trapping will be 
> there. ARIA roles will make sense instead of being scattered like 
> confetti. Contrast ratios will be checked before you ship, not after 
> someone files a complaint.
>
> That is not a magic fix. That is a better starting point. You still 
> need to test. You still need real users. You still need to care. But 
> at least you are not starting from zero every single time.
>
> If anyone tries to sell you a tool that replaces accessibility 
> testing, run. This is not that tool. This is the tool that makes the 
> code better before testing even begins.
>
> It Moved
>
> The project does not live under my personal GitHub account anymore. It 
> is at the Community Access organization now.
>
> That was deliberate. This is not my project. It is not Jeff’s project. 
> It is a community project. The more perspectives and lived experiences 
> that go into these agents, the better they serve the people who need them.
>
> Thirty Pull Requests in Five Days
>
> I keep coming back to this number because it tells the story better 
> than anything else I can say.
>
> Thirty pull requests merged in five days. That means thirty separate 
> changes were proposed, reviewed, and added to the project. Three 
> hundred and sixty files changed. Seventy-three thousand lines of code 
> added. Thirty-four security vulnerabilities identified and resolved. 
> Path traversal prevention. Injection protection. ZIP bomb limits. 
> Input validation at every call site.
>
> This was not a casual weekend project. This was a sprint. Jeff and I 
> were building in parallel, reviewing each other’s code, catching 
> issues, pushing fixes. The velocity was unlike anything I have 
> experienced on an open source project.
>
> And it happened because people who need accessible software decided to 
> stop waiting for someone else to build it.
>
> Why This Matters
>
> AI coding tools generate code at a speed and scale that humans never 
> could. If that code is inaccessible by default, the problem is not 
> getting smaller. It is getting bigger. Fast.
>
> Ninety-five point nine percent of the top one million websites already 
> have detectable accessibility failures. That number has barely moved 
> in years. AI tools risk making it worse by automating the same 
> mistakes at a scale no human team could match.
>
> I am a screen reader user. When AI generates a modal without focus 
> trapping, I am the person who gets stuck. When it skips live regions 
> on search results, I am the person who hears nothing. When it uses a 
> div with an onClick instead of a button, I am the person who cannot 
> activate it with my keyboard.
>
> But here is what I have learned over the past five days. I am not the 
> only one who feels this way. Jeff feels it. The people who starred the 
> repo and opened issues feel it. This is not one person’s frustration. 
> It is a shared experience across an entire community that has been 
> dealing with inaccessible software for decades.
>
> That is why this is not just me. That is why it cannot be just me. One 
> person’s agents catch one person’s blind spots. A community’s agents 
> catch the patterns that none of us would find alone.
>
> Version 2.0
>
> On Tuesday, Jeff and I got on a call and decided it was time. We were 
> going to release version 2.0.
>
> Five days earlier I had six agents and a personal repo. Now we had 
> forty-seven agents, three platforms, a GitHub organization, a website, 
> and a community. It was not a preview anymore. It was a release.
>
> We published the official announcement yesterday. You can read the 
> full press release on the Community Access website:
>
> https://community-access.github.io/news.html#post/accessibility-agents-v2-launch
>
> I am sharing it here because this community has followed this journey 
> from the beginning. You read the preview post on Friday. You saw the 
> Swift agent team launch. You have been here for the frustration and 
> the building and the breakthroughs. You deserve to see how it landed.
>
> Forty-seven agents. Three platforms. One command to install. Zero 
> cost. That is the headline. But the real story is that a community 
> built this in five days because the tools we depend on every day were 
> not building it for us.
>
> Be Part of This
>
> So now I am promoting it. And I am hoping you will try it out.
>
> I want to make this as easy as possible. You do not need to be a 
> developer to help. You do not need to write code. You do not need to 
> know what ARIA stands for. If you care about accessible software, 
> there is something you can do right now.
>
> Talk about it. Share the project with someone who builds software. 
> Post about it. Mention it in a conversation. The biggest thing holding 
> accessibility back is that not enough people know it is a problem. 
> Every time someone new hears about this project, that changes a little.
>
> Try it. Install it with one command. Use it on your next project. See 
> what it catches. See what it misses.
>
> If you find a bug, file it. Go to the GitHub repo, open an issue, and 
> describe what happened. What you expected. What you got instead. That 
> is it. A good bug report is one of the most valuable contributions 
> anyone can make. It does not take expertise. It takes honesty.
>
> If you want to contribute code, the agents are plain markdown files. 
> You do not need special tooling. You do not need permission. Fork it, 
> make a change, open a pull request. Jeff did exactly that on Saturday 
> morning and look where we are now.
>
> Website: https://community-access.github.io/
>
> GitHub: https://github.com/Community-Access/accessibility-agents
>
> Thank You
>
> To Jeff, for picking this up on Saturday morning and not putting it 
> down. For removing the hooks when I was still trying to fix them. For 
> writing forty-three commits in five days. For caring about this as 
> much as I do.
>
> To every contributor who showed up, opened a PR, filed an issue, or 
> starred the repo. You turned a frustrated Friday night into something 
> real.
>
> And to everyone reading this. If you build software, you have the 
> power to make it accessible. These agents are one way to start. But 
> they are not the finish line. They are the starting block.
>
> This is how it starts. Not with a company. Not with funding. With 
> people who got tired of fighting the same fight every day and decided 
> to build something that fights back.
>
> That is not just me. That is all of us.
>
>
> _______________________________________________
> NFBCS mailing list
> NFBCS at nfbnet.org
> http://nfbnet.org/mailman/listinfo/nfbcs_nfbnet.org
> To unsubscribe, change your list options or get your account info for NFBCS:
> http://nfbnet.org/mailman/options/nfbcs_nfbnet.org/tyler%40tysdomain.com
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://nfbnet.org/pipermail/nfbcs_nfbnet.org/attachments/20260225/120374cc/attachment.htm>