Terence Eden walked into a drab London housing benefits office years ago. The computers were old. The connections were slow. Yet the government forms loaded fast. They worked on every device. They reached everyone who needed them.
That experience stayed with him. In January 2021 he published a post that still circulates on Hacker News and developer forums today. Terence Eden’s blog laid out a simple truth: plain HTML delivers results that complex JavaScript stacks often promise but rarely match in practice.
The GOV.UK team built their pages with basic markup. They added modest CSS for clarity. They avoided heavy scripts. The pages stayed lightweight. They functioned on outdated browsers and poor networks. They served citizens who could not afford the latest phones. Results like these force a question many teams still dodge.
Fast forward to 2026. Web Almanac data shows median Lighthouse accessibility scores climbed to 85 percent last year. Improvements came in labeled form fields, better ARIA usage, and fewer missing alt texts. Yet the gains remain uneven. Sites built on modern frameworks continue to ship complex widget trees that break screen readers and inflate load times. (HTTP Archive Web Almanac 2025)
WebAIM’s 2026 predictions point to a quiet correction. After years of custom components wrapped in layers of JavaScript, teams are rediscovering native elements. Buttons. Dialogs. Details and summary tags. Select menus. These pieces carry built-in behaviors that assistive technology understands without extra code. They reduce debugging time. They improve consistency across browsers. (WebAIM 2026 Predictions)
But the story goes beyond government services and accessibility audits. In May 2026, Thariq Shihipar, who works on the Claude Code team at Anthropic, made an unexpected switch. He stopped feeding markdown to his AI agents and started requesting self-contained HTML files instead. The output changed everything.
Tables became sortable. Lists turned into navigable boards. Reports gained inline charts and expandable sections. Readers didn’t just scan walls of text. They interacted, filtered, and understood faster. Simon Willison covered the shift on his site, noting how HTML gives agents richer ways to present information that humans actually engage with. (Simon Willison’s blog)
Shihipar’s examples, collected in a companion gallery, show planning canvases, annotated code reviews, and interactive explainers. Each one lives in a single file. No external dependencies. Open it in any browser and it works. The approach trades document skimming for genuine reading. (Thariq Shihipar’s HTML examples)
Critics point out the costs. HTML output consumes more tokens. Files grow larger. Context windows fill quicker. Yet the productivity payoff appears real. Developers report catching issues they previously missed in plain text. Review quality rises. And the final artifact needs no conversion step before sharing.
Performance numbers back the broader case. Semantic HTML tends to produce smaller DOM trees. Browsers parse and render it with less overhead. Mobile devices, especially in emerging markets, feel the difference immediately. SEO benefits follow because search engines reward clear heading structures and meaningful links over div-soup applications.
Accessibility experts have repeated the message for years. The W3C Web Accessibility Initiative stresses that native HTML provides the strongest foundation. It requires no extra ARIA attributes in most cases. It works when JavaScript fails. It reaches users with disabilities, slow connections, or older hardware. (W3C Web Accessibility Initiative)
Regulatory pressure is mounting too. The U.S. Department of Justice updated Title II of the ADA in 2024. Starting in 2026, state and local governments must meet WCAG 2.1 Level AA standards for their digital services. Deadlines arrive this year for larger entities. Many will discover that retrofitting complex single-page applications costs far more than building correctly from the start. (Berkshire Hathaway Guard Insurance Group analysis)
So why does the industry keep chasing complexity? Frameworks sell speed of development. They offer pre-built components and familiar patterns. Marketing teams demand pixel-perfect animations. Product managers push for feature parity with native apps. The result is often a heavy, fragile product that excludes as many users as it attempts to delight.
Progressive enhancement offers a different path. Start with a functional HTML document. Add CSS for presentation. Layer JavaScript only where it adds clear value. The core experience survives when scripts don’t load. Users on restricted networks or corporate laptops still get the information they need.
Government digital teams learned this lesson under budget pressure and legal mandates. They couldn’t afford to ship broken experiences. Private companies face similar constraints now, whether from accessibility lawsuits, Core Web Vitals scores, or user frustration on mobile. The data keeps pointing the same direction.
HTML’s effectiveness looks unreasonable only because expectations have grown distorted. We expect every page to feel like an app. We measure success in engagement metrics that reward motion over clarity. We forget that many tasks require nothing more than clear text, logical structure, and reliable links.
Recent discussions on X show the original 2021 post still resonates. Developers rediscover it during performance audits or after accessibility complaints pile up. Some share new examples of single-file HTML tools that replace multi-megabyte applications. The pattern repeats.
Teams that embrace semantic markup ship faster in the long run. They debug less. They maintain code with greater confidence. Their products reach wider audiences. They score better on every major metric that matters to users and regulators alike.
The housing benefits office in London didn’t need a React app. Citizens needed information they could trust and forms that worked. The same holds for most websites in 2026. The tools have grown more powerful. The fundamentals have not changed.
Plain HTML. A touch of CSS. JavaScript used with restraint. This combination delivers reliability that no amount of framework churn has yet surpassed. The evidence keeps accumulating. The question is whether the industry will finally listen.
WebProNews is an iEntry Publication