How to Use AI to Make Software Development Accessible

AI coding assistants are changing the way software gets built. I've recently taken a deep dive into three powerful AI coding tools: Claude Code (Anthropic), OpenAI Codex, and Cursor. Here’s what stood out to me: Claude Code (Anthropic) feels like a highly skilled engineer integrated directly into your terminal. You give it a natural language instruction, like a bug to fix or a feature to build and it autonomously reads through your entire codebase, plans the solution, makes precise edits, runs your tests, and even prepares pull requests. Its strength lies in effortlessly managing complex tasks across large repositories, making it uniquely effective for substantial refactors and large monorepos. OpenAI Codex, now embedded within ChatGPT and also accessible via its CLI tool, operates as a remote coding assistant. You describe a task in plain English, it uploads your project to a secure cloud sandbox, then iteratively generates, tests, and refines code until it meets your requirements. It excels at quickly prototyping ideas or handling multiple parallel tasks in isolation. This approach makes Codex particularly powerful for automated, iterative development workflows, perfect for agile experimentation or rapid feature implementation. Cursor is essentially a fully AI-powered IDE built on VS Code. It integrates deeply with your editor, providing intelligent code completions, inline refactoring, and automated debugging ("Bug Bot"). With real-time awareness of your codebase, Cursor feels like having a dedicated AI pair programmer embedded right into your workflow. Its agent mode can autonomously tackle multi-step coding tasks while you maintain direct oversight, enhancing productivity during everyday coding tasks. Each tool uniquely shapes development: Claude Code excels in autonomous long-form tasks, handling entire workflows end-to-end. Codex is outstanding in rapid, cloud-based iterations and parallel task execution. Cursor seamlessly blends AI support directly into your coding environment for instant productivity boosts. As AI continues to evolve, these tools offer a glimpse into a future where software development becomes less about writing code and more about articulating ideas clearly, managing workflows efficiently, and letting the AI handle the heavy lifting.

AI generates code faster than humans ever could. If that code is inaccessible by default, the problem is not getting smaller. It is getting bigger. Fast. I am a screen reader user. I use AI coding tools every day. And every day I fight for the basics. Label the inputs. Trap focus in the modal. Use a button, not a div. Add a live region so the screen reader knows something changed. On Friday night I had enough. I built 6 specialized AI agents that enforce accessibility in Claude Code. I published the repo, shared a writeup, and went to bed. By Saturday morning, Jeffrey Bishop was already pushing code. Jeff is blind, like me. He did not ask can I help. He started building. 43 commits in 5 days. He ripped out the part that was not working and replaced it with something better. 5 days later: 47 agents across 4 teams. 3 platforms. 30 pull requests merged. 360 files changed. 73,000 lines of code. 34 security vulnerabilities identified and resolved. One command to install. Free. MIT licensed. It runs on Claude Code, GitHub Copilot, and Claude Desktop. It supports macOS, Linux, and Windows. This is not an overlay. It does not touch your website. It does not inject JavaScript. It does not promise compliance. There is no widget, no badge, no fee. It is a developer tool that raises the floor. Code that comes out of AI with these agents active will have labels, focus trapping, proper ARIA, and contrast checks before you even start testing. That is not a magic fix. That is a better starting point. 95.9% of the top million websites have detectable accessibility failures. AI tools are automating those same mistakes at scale. Two blind developers and a community decided to stop waiting for someone else to fix it and built something that fights back. The project lives under a GitHub organization called Community Access because this is bigger than any one person. The more lived experiences that go into these agents, the better they serve the people who need them. Star it. Try it. Break it. Tell us what is missing. Full story: https://lnkd.in/gKzbYJ93 Press release: https://lnkd.in/gtjtiYD4 GitHub: https://lnkd.in/gMJqKXWc #accessibility #a11y #OpenSource #WebAccessibility #WCAG #ClaudeCode #GitHubCopilot #AI #DevTools #AssistiveTechnology #ScreenReader #WebDev

Your engineers only spend 30% of their time writing code. AI tools are getting faster every month. But if we only use them to optimize that 30%, we’re missing the bigger opportunity. The real drag on engineering teams isn’t just how long it takes to code. It’s everything else. Here’s what fills the other 70%: •Chasing down unclear requirements •Sitting in meetings with no clear outcomes •Reviewing pull requests with inconsistent standards •Updating tickets and writing status reports •Answering Slack threads that go nowhere •Debugging issues without structured history •Repeating the same explanation of tech debt, again and again •Waiting on test runs and deployment gates •Switching contexts so often they lose flow entirely I’ve seen teams implement AI coding assistants and celebrate a 50%+ speedup—in just the 30% coding time. But if you do the math, that’s only a 15% productivity gain overall. Helpful? Sure. Transformative? Not yet. The teams moving faster right now are thinking differently. They’re using AI tools to remove the clutter around the code, not just speed up the code itself. •Auto-summarizing Slack threads and meeting notes •Auto-generating technical documentation and PR templates •Using AI to enrich ticket context before a dev even picks it up •Automating deployment comms with intelligent summaries •Creating internal agents that proactively surface blockers If you want a truly AI-first team, you can’t just deploy tools for the 30%. You need to reimagine the 70%. That’s where the friction lives, and where the real leverage is hiding. Have you mapped where your team spends their time? If not, that’s where your AI roadmap should start. #EngineeringLeadership #AIProductivity #DeveloperExperience #TechStrategy #MetaShift #SoftwareDevelopment #AIatWork

In the age of AI, our workflows are evolving. For decades, developers debated: 🧪 TDD (Test-Driven Development): write tests first, then code. 💻 Code-First: write code, then add tests later. But with AI tools like Copilot, Claude Code (and others), a new model is emerging: Documentation-First Development (DFD). Here’s why: ✨ Documentation becomes the source of truth for humans and AI. ✅ Tests can be generated directly from documentation. 🤖 AI can build the implementation and even highlight blindspots by suggesting edge cases you may not have considered. This is the real power of context-aware AI for developers: the richer the documentation, the smarter and more reliable the AI outputs. Example: you document a simple “user registration” flow. AI might ask: - What if the email format is invalid? - What if the confirmation email fails to send? - Should you block disposable emails or brute-force attempts? That feedback loop looks like this: Docs → Tests → Code → AI Feedback → Better Docs → Stronger Tests → Stronger Code. The result: 🔹 Clearer requirements 🔹 Smarter context-aware AI outputs 🔹 Higher-quality, maintainable code In short, documentation isn’t just paperwork anymore. In the AI era, documentation is the superpower that unlocks the potential of context-aware development. And, with a few prompts, we can even use AI to help us generate the documentation for us! #AI #SoftwareDevelopment #ContextAwareAI #GitHubCopilot

In our new #CHI25 paper, we studied how #GenAI coding assistants like GitHub Co-pilot impact developers with visual impairments. Despite progress in accessibility for developers who are visually impaired, generative AI coding assistants like GitHub Copilot introduce new challenges and opportunities that remain underexplored. We studied how developers who are visually impaired use GitHub Copilot and found a complex relationship: AI provides powerful new capabilities but also introduces new accessibility challenges. Key finding: AI coding assistants like Github Co-pilot give developers who are visually impaired more CONTROL by handling tedious tasks (like generating documentation) and allowing them to focus on higher-level strategic decisions - much like a pilot overseeing an aircraft's systems. However, it introduces new CONTEXT SWITCHING problems. The dynamic nature of AI suggestions and new Co-pilot features disrupts the sequential workflows that developers with visual impairments rely on. Or if I say the other way around, their mental model for coding. Developers were overwhelmed by constant AI suggestions. The constant stream of suggestions (especially ghost text) can create information overload for screen reader users. Imagine all these ghost text suggestions getting rendered on your screen reader. We propose "AI timeouts" - periodic breaks from AI intervention that allow developers to focus and think without disruption, especially important for screen reader users facing information overload. Despite challenges, Developers experienced significant productivity gains! AI assistants proactively anticipated coding needs and generated relevant code, reducing the need to navigate multiple documentation pages - a process that's especially challenging with screen readers. Co-pilot-like assistants can act as an "always-available coding partner," providing non-judgmental support. This reduced reliance on asking colleagues for help, valuable in workplace environments where developers might feel hesitant to frequently request assistance. Using Activity Theory as our framework, we identified key contradictions between AI tools' design and the needs of visually impaired developers. Most AI-enabled IDEs assume visual scanning of information, a significant accessibility barrier. We introduce a concept, "AI Timeouts," to reduce cognitive load and enable temporary pauses in AI interventions. Our research findings inform not just coding assistants but provide valuable insights if you are designing agentic AI systems that preserve user autonomy and can effectively support diverse user groups with varying levels of interaction. Thanks to my amazing collaborators, Claudia Flores-Saviaga, PhD, Ben Hanrahan, Steven Clarke, and Dr. Saiph Savage and for making this work possible! Catch us presenting our work at the ACM CHI Conference in Japan on Wednesday, April 30.

I’ve spent the last couple years exploring ways that AI can be used to automate parts of the software development process. In this video, you’ll see a demo of me taking a JIRA user story and automatically generating Cucumber tests and a basic implementation plan combining GitHub Actions with Gemini 1.5 Pro. With just a few lines of code, we were able to create an AI pipeline that hints at the ability to drastically speed up development time and generate artifacts to be used in other parts of other pipelines. There’s already best practices forming around using Cursor’s agentic flows that include a step of having it generate an implementation plan. Why not automate that as well? All the code for this is available at https://lnkd.in/eFfxtHWa . The particularly interesting parts where we’re using AI are under the .github/workflows directory (https://lnkd.in/exkKMZaJ). To use it you’ll also need to set up a few API keys and environment variables. If you’re looking for help you can pop in to the Sublayer Discord (https://lnkd.in/eiaJV7JX) and I should be around to guide you through it. Want to see more explorations like this and get notified as soon as we release anything? Subscribe to my new newsletter - Works on My Machine - https://lnkd.in/eMe2NdjZ where I'll be sharing demos like this, longer form posts about the implications of AI like I've written in the past, and product announcements based on the ideas I share in the posts.

Anthropic says Claude can stay focused, coding, for 30 hours. Bain’s Technology Report 2025 shows 80% of companies see no ROI … Why? Because focus isn’t the problem. Context is. And fixing context means rethinking how and where we use AI across the software lifecycle. Sure, AI can follow clean instructions, especially on a new application build, but it still doesn't understand how one line of code breaks something three levels down. The report found developers are actually 19% slower with AI assistants, they spent more time fixing hallucinations than writing code. Here were some of the other findings from the Bain report: 🔹 Value shows up in narrow tasks but quickly disappears in the large, messy codebases most organizations live with 🔹 Developers expected AI to speed them up. Instead, they spent more time verifying and repairing its outputs 🔹 Community tests showed AI answers are "almost right." But in software, almost right = wrong. And wrong is sometimes harder to fix 🔹 Security teams reported 10x more vulnerabilities in AI-assisted code Sure, Claude's latest findings are impressive, but AI tends to do fine when the problem is neat and self-contained. In real life... most enterprise codebases aren't nearly that clean. They're thousands of interconnected parts tied to old architecture, buried business logic, and Steve’s 2015 workaround still holding things together. It needs to adapt to: ☑️ Custom frameworks ☑️ Undocumented conventions ☑️ And yes, Steve's 2015 workaround that still holds the system together even after he's left So where should organizations actually focus? 1️⃣ End-to-end SDLC--> Don’t stop at coding. Deploy AI across requirements, design, testing, code review, CI/CD, and release management 2️⃣ Legacy code understanding--> Help developers navigate the messy reality of decades-old codebases. Make understanding the code accesssible (e.g. Crowdbotics) 3️⃣ Impact analysis & data flow--> Use AI to model how changes ripple across systems before deploying to prevent surprises (e.g. Cloudera's Octopai) 4️⃣ Institutional knowledge capture--> Train LLMs on your debugging history, architectural decisions, and runbooks. Context lives in Slack threads and old Confluence pages 5️⃣ Living documentation--> Auto-generate and maintain architecture diagrams, API specs, and SOPs as code evolves. Documentation shouldn’t lag 6️⃣ Security context by design--> AI should be constrained by your org’s secure coding standards so it doesn’t create vulnerabilities faster than you can patch them. The bigger picture? AI coding assistants aren’t the endgame. The real transformation comes from redesigning the entire lifecycle and giving AI the context it needs to operate in messy, real-world environments. Because in coding, context will always beat focus. Bain research: https://lnkd.in/eiGqnnzD Claude News: https://lnkd.in/ehCNpGme

A mental model for AI integration in software With AI, "intelligence" is now a commodity. You can think of AI as a reliable but nondeterministic function that, given a specific instruction, can provide a particular output. The job of this function cannot be written with logic. It is written with intelligence. For example, if I ask a function to draw an apple, there is no logical way to draw a real apple since an apple is nondeterministic. You need intelligence to draw it. Or, say, summarize some text; there is no logical way to do it. But with some intelligence, it can be summarized. Software features and architectures so far have always been designed around logic. What is logically possible. What can be done with "if"'s and "else"'s. A deterministic outcome that does something. But now we have a new tool to use, which is intelligence. We can build features that require intelligence and cannot be accomplished with logic. This opens a new way of thinking about many things, but not everything. Reliability is still essential. So we need to break intelligence functions down to a level where its nondeterministic outcome can reliably be used. Let's use this way of thinking and apply it to Jira, a tool with which most of us are familiar. Here are a few enhancements possible only with AI - 1. On hover over a Jira ticket, see its summary 2. When I write a description, auto-generate a good title 3. When I attach a wireframe, draft a spec that I can update 4. Highlight stories in backlog / icebox that might have the most return on investment, with an understanding of market and competition 5. Given a feature/bug, identify the source code files that might have an impact to give a headstart to developers All of the above functions require intelligence, but they are reliably helpful even with a nondeterministic outcome. Intelligence has already become cheap enough that we must now think of both logical and intelligent functions when building or enhancing any software systems.

Why does it seem like accessibility is often treated as an afterthought? 🕒 In my experience, companies wait until audits or legal pressures force them to act, but this reactive approach costs time, money, and damages user trust. Why let it come to that? I’ve seen forward-thinking organizations start to shift accessibility left—embedding it directly into every stage of development. 🌍 From the requirement phase to testing, accessibility checks can now be automated, flagging and resolving issues in real-time. This isn’t just about ticking boxes for compliance; it’s about creating a seamless, inclusive experience for every user from the start. Today’s AI-driven accessibility tools don’t just identify issues—they help solve them. With checks happening within the developer’s IDE, real-time feedback ensures accessibility is built into the code before it even reaches production. 🛠️ This approach saves on manual work, lowers costs, and empowers developers to meet standards like WCAG and ADA efficiently. By making accessibility part of the core development platform, we’re not just avoiding fines—we’re building a brand that prioritizes inclusion and usability for everyone. It’s time to make accessibility a key business principle, not just a checkbox. 🔍💡

AI in software development is about enabling our engineers to focus on high-value work, not replacing them. At Tesco Technology, we use AI as a copilot to boost productivity and streamline routine tasks. Here’s how we make it practical across teams: For leaders: Invest in structured AI training and upskilling. Set clear expectations about what AI can and cannot do, so teams use it with confidence and trust. For platform owners: Integrate AI seamlessly into workflows. Automate repetitive steps, display confidence scores, and create clear support/tutorials to help every engineer use AI as a transparent assistant, not a black box. For enterprise scale: Begin with small pilots and collect feedback. Plan for scaling, measure productivity improvements, share successes, and iterate so the adoption endures and provides value at every stage. AI copilots aren’t just for coding. We’ve enhanced documentation and user guides, reduced tedious work, and improved quality across materials. Success comes from integrating AI into our usual practices, supported by clear guidance and feedback mechanisms (Tools like DX are invaluable for this!). Every developer can benefit, and every team is empowered to progress more quickly. If you’re rolling out AI tooling and copilots, focus on practical wins and clear measurement. Let’s drive developer productivity together! #tescotechnology #devex #ai #teamwork #ArtificialIntelligence #Technology #Innovation #DeveloperExperience #Leadership #Productivity #DigitalTransformation #FutureOfWork #TechLeadership #EnterpriseAI