A text-mode web browser with AI help, inspired by Lynx, plus TextFirst.css for text-first websites.
Mobile Web: The Same Mistakes, Smaller Screen
Status: Historical Pattern Recognition Date: 2025-01-28
The Mobile Web Evolution (or: How We Overcomplicated Everything Again)
Phase 1: WAP/WML Era (1999-2007)
"Mobile needs its own language!"
Technology: WAP (Wireless Application Protocol) + WML (Wireless Markup Language)
<?xml version="1.0"?>
<!DOCTYPE wml PUBLIC "-//WAPFORUM//DTD WML 1.1//EN"
"http://www.wapforum.org/DTD/wml_1.1.xml">
<wml>
<card id="main" title="Welcome">
<p>
Welcome to our mobile site!
<anchor>
Menu
<go href="#menu"/>
</anchor>
</p>
</card>
<card id="menu" title="Menu">
<p>
<a href="news.wml">News</a><br/>
<a href="about.wml">About</a>
</p>
</card>
</wml>
The Problem:
- Completely different from HTML
- Required separate mobile site
- Terrible user experience
- Nobody wanted to maintain two codebases
- Died with the iPhone
Developer workflow:
- Write HTML site for desktop
- Write WML site for mobile
- Maintain both forever
- Cry
Phase 2: Separate Mobile Sites (2007-2010)
"Just make m.website.com!"
Approach: Detect mobile browser → redirect to m.website.com
Desktop site (www.example.com):
<!DOCTYPE html>
<html>
<head>
<title>Example Corp</title>
<link rel="stylesheet" href="desktop.css">
</head>
<body>
<div id="header">...</div>
<div id="sidebar">...</div>
<div id="content">...</div>
</body>
</html>
Mobile site (m.example.com):
<!DOCTYPE html>
<html>
<head>
<title>Example Corp</title>
<link rel="stylesheet" href="mobile.css">
<meta name="viewport" content="width=device-width">
</head>
<body>
<div id="header-mobile">...</div>
<div id="content">...</div>
<!-- No sidebar on mobile -->
</body>
</html>
mobile.css:
body {
width: 320px; /* iPhone width */
font-size: 14px;
}
#header-mobile {
padding: 10px;
background: #333;
}
/* Everything simplified for mobile */
Problems:
- Two completely separate codebases
- m.example.com and www.example.com drift apart
- "Desktop site" link on mobile
- "Mobile site" link on desktop (for debugging)
- SEO nightmare (duplicate content)
- Users get stuck on wrong version
- Features only on desktop site
- Tablet users confused (which site?)
Developer workflow:
- Build desktop site
- Build mobile site
- Keep them in sync
- Fail to keep them in sync
- Mobile site becomes outdated
- Users complain
Phase 3: Responsive Design Revolution (2010-2012)
"One site to rule them all!" - Ethan Marcotte's big idea
The Breakthrough: Media queries!
<!DOCTYPE html>
<html>
<head>
<title>Example Corp</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="style.css">
</head>
<body>
<header>...</header>
<nav>...</nav>
<main>...</main>
<aside>...</aside>
</body>
</html>
style.css:
/* Mobile first */
body {
font-size: 16px;
padding: 1rem;
}
nav {
/* Stack vertically on mobile */
}
aside {
/* Full width on mobile */
}
/* Tablet */
@media (min-width: 768px) {
nav {
display: flex;
}
aside {
width: 30%;
float: right;
}
}
/* Desktop */
@media (min-width: 1024px) {
body {
max-width: 1200px;
margin: 0 auto;
}
aside {
width: 25%;
}
}
The Magic:
- One HTML file
- One CSS file
- Works on all devices
- Same content everywhere
This was BRILLIANT. This was the answer.
✅ One codebase ✅ Same content on all devices ✅ Progressive enhancement ✅ Mobile-first thinking ✅ No redirects ✅ SEO friendly
Developer workflow:
- Write semantic HTML
- Write mobile-first CSS
- Add media queries for larger screens
- Test on devices
- Done
Phase 4: The Framework Creep (2012-2015)
"But we need a framework for responsive!"
Bootstrap arrives:
<div class="container">
<div class="row">
<div class="col-xs-12 col-sm-6 col-md-4">
Content
</div>
<div class="col-xs-12 col-sm-6 col-md-4">
Content
</div>
<div class="col-xs-12 col-sm-12 col-md-4">
Content
</div>
</div>
</div>
What happened:
- Grid systems for layout
- 12-column responsive grids
- xs/sm/md/lg/xl breakpoints
- "Mobile-first" but actually complex
- Every site looks the same
Problems:
- Lost semantic HTML
- Div soup returns
- Need to learn framework
- 200 KB CSS for simple site
- Everyone's site has the same breakpoints
But it was still OK because: ✅ No build process (yet) ✅ Still just HTML + CSS ✅ Works on all devices ✅ Can view source
Phase 5: Touch Events & JavaScript Madness (2013-2016)
"Mobile needs different interactions!"
The realization: Touch isn't click
// Desktop: click
element.addEventListener('click', handleClick);
// Mobile: Also click, but...
// - No hover
// - Touch events
// - Gestures
// - Pinch zoom
// - Swipe
// So developers do this:
element.addEventListener('touchstart', handleTouch);
element.addEventListener('click', handleClick);
// And then deal with:
// - Touch fires before click
// - Prevent default to stop double-firing
// - Handle both touch and mouse
// - Detect device type
// - Feature detection vs device detection
Libraries appear:
- Hammer.js (gesture recognition)
- FastClick (eliminate 300ms delay)
- Touch events polyfills
- Mobile-specific UI libraries
The complexity grows:
// Before (desktop):
button.onclick = () => console.log('clicked');
// After (mobile-aware):
import Hammer from 'hammerjs';
const hammer = new Hammer(button);
hammer.on('tap', () => {
console.log('tapped');
});
// But wait, desktop users don't have Hammer
// So also:
if (!('ontouchstart' in window)) {
button.onclick = () => console.log('clicked');
}
Started simple, got complicated.
Phase 6: Mobile-First CSS Frameworks (2014-2017)
"Design for mobile, enhance for desktop!"
Foundation, Material UI, etc.:
<div class="grid-container">
<div class="grid-x grid-margin-x">
<div class="cell small-12 medium-6 large-4">
Content
</div>
</div>
</div>
Plus rounded corners obsession:
/* Before iOS (2007): */
.box {
/* Square corners, deal with it */
}
/* After iOS: */
.box {
border-radius: 10px;
-webkit-border-radius: 10px; /* Safari */
-moz-border-radius: 10px; /* Firefox */
}
/* Everyone wants iPhone-style rounded corners */
And shadows:
.card {
box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-webkit-box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}
The "make it look like iOS" trend:
- Rounded corners everywhere
- Subtle shadows
- Flat design
- Cards
- Material Design copies iOS
- Everyone copies everyone
Phase 7: Native App Competition (2015-2018)
"Web apps can't compete with native!"
The arms race:
Native Apps:
✅ Fast
✅ Smooth animations
✅ Offline support
✅ Push notifications
✅ Home screen icon
✅ Access to device features
Web Apps:
❌ Slow
❌ Janky scrolling
❌ No offline
❌ No notifications
❌ Just a bookmark
❌ Limited device access
Solutions attempted:
- PhoneGap/Cordova (web app in native wrapper)
- Ionic (framework for hybrid apps)
- React Native (JavaScript but native UI)
- Progressive Web Apps (web apps with native features)
The irony: Spent years making web apps act like native apps, when websites already worked.
Phase 8: Progressive Web Apps (2016-2020)
"Web apps can be native-like!"
Requirements:
manifest.json
service-worker.js
HTTPS
Responsive design
Fast loading
Offline support
Push notifications
Install prompt
Simple blog now needs:
// service-worker.js (200 lines)
self.addEventListener('install', (event) => {
event.waitUntil(
caches.open('v1').then((cache) => {
return cache.addAll([
'/',
'/styles.css',
'/script.js',
'/offline.html'
]);
})
);
});
self.addEventListener('fetch', (event) => {
event.respondWith(
caches.match(event.request).then((response) => {
return response || fetch(event.request);
})
);
});
manifest.json:
{
"name": "My Simple Blog",
"short_name": "Blog",
"start_url": "/",
"display": "standalone",
"background_color": "#ffffff",
"theme_color": "#000000",
"icons": [
{
"src": "icon-192.png",
"sizes": "192x192",
"type": "image/png"
},
{
"src": "icon-512.png",
"sizes": "512x512",
"type": "image/png"
}
]
}
For a blog.
That could have been:
<html>
<body>
<article>
<h1>My Blog Post</h1>
<p>Content...</p>
</article>
</body>
</html>
Phase 9: React Native & Cross-Platform (2017-2021)
"Write once, run on iOS and Android!"
The promise: One codebase for mobile apps
The reality:
import React from 'react';
import {
View,
Text,
StyleSheet,
Platform,
Dimensions
} from 'react-native';
const MyComponent = () => {
const windowWidth = Dimensions.get('window').width;
return (
<View style={styles.container}>
<Text style={[
styles.text,
Platform.OS === 'ios' ? styles.iosText : styles.androidText
]}>
Hello World
</Text>
</View>
);
};
const styles = StyleSheet.create({
container: {
flex: 1,
justifyContent: 'center',
alignItems: 'center',
backgroundColor: '#fff'
},
text: {
fontSize: 20
},
iosText: {
fontFamily: 'San Francisco'
},
androidText: {
fontFamily: 'Roboto'
}
});
Could have been (responsive HTML):
<div style="text-align: center">
<p>Hello World</p>
</div>
Phase 10: Tailwind on Mobile (2020-2024)
"Utility-first works on mobile too!"
<div class="container mx-auto px-4">
<div class="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-4">
<div class="bg-white rounded-lg shadow-md p-4 sm:p-6 lg:p-8">
<h2 class="text-lg sm:text-xl lg:text-2xl font-bold mb-2">
Title
</h2>
<p class="text-sm sm:text-base text-gray-600">
Content
</p>
</div>
</div>
</div>
For every. single. element.
Problems:
- Class soup on mobile too
- Have to think about sm:/md:/lg: for everything
- Copy-paste nightmare
- Unreadable HTML
- Lost all semantic meaning
Phase 11: TextFirst.css (2025)
"What if we just... used media queries?"
<!DOCTYPE html>
<html>
<head>
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="textfirst.css">
</head>
<body>
<article>
<h1>My Content</h1>
<p>This is <color name="success">good content</color>.</p>
<menu type="numbered">
<li><a href="#home">Home</a></li>
<li><a href="#about">About</a></li>
</menu>
</article>
</body>
</html>
textfirst.css handles it:
/* Mobile first - base styles */
body {
padding: 1rem;
font-size: 16px;
}
menu li {
padding: 0.75rem;
margin: 0.5rem 0;
}
/* Tablet and up */
@media (min-width: 768px) {
body {
padding: 2rem;
}
menu li {
display: inline-block;
margin: 0 1rem;
}
}
/* Desktop */
@media (min-width: 1024px) {
body {
max-width: 80ch;
margin: 0 auto;
}
}
That's it. Works on:
- ✅ iPhone (all sizes)
- ✅ Android (all sizes)
- ✅ iPad
- ✅ Desktop
- ✅ TV browsers
- ✅ Feature phones with basic browsers
- ✅ Text browsers
No framework. No build process. No JavaScript.
The Pattern Repeats
Desktop Web
Simple HTML (1995)
↓
Photoshop slicing (2000s)
↓
CSS frameworks (2010s)
↓
Build tools required (2020s)
↓
TextFirst.css - back to simple (2025)
Mobile Web
Simple HTML with viewport (2007)
↓
Separate mobile sites (2008)
↓
Responsive design (2010) ← This was the answer!
↓
Mobile frameworks (2012)
↓
React Native / PWAs (2016)
↓
Build tools required (2020)
↓
TextFirst.css - back to responsive (2025)
We had the answer in 2010: Responsive design with media queries.
Then we spent 15 years making it complicated again.
What We Added That We Didn't Need
❌ Separate Mobile Sites
HTML with @media queries solves this.
❌ Grid Frameworks
CSS Grid and Flexbox are built into browsers now.
❌ Touch Event Libraries
Click events work on touch devices.
❌ React Native
Responsive HTML works on mobile browsers.
❌ Progressive Web Apps
Most websites don't need offline support.
❌ Build Processes
CSS media queries need no compilation.
What Actually Matters for Mobile
✅ Viewport Meta Tag
<meta name="viewport" content="width=device-width, initial-scale=1">
This one tag makes HTML work on mobile. That's it.
✅ Media Queries
@media (max-width: 768px) {
/* Mobile styles */
}
Adjust layout for small screens. That's it.
✅ Touch-Friendly Sizes
button {
padding: 0.75rem 1.5rem; /* Big enough to tap */
margin: 0.5rem; /* Space between tappable things */
}
Make buttons bigger. That's it.
✅ Readable Font Sizes
body {
font-size: 16px; /* Don't go smaller on mobile */
}
Use readable fonts. That's it.
The TextFirst.css Mobile Strategy
1. Mobile-First CSS
/* Base styles work on mobile */
body {
padding: 1rem;
font-size: 16px;
line-height: 1.6;
}
/* Enhance for larger screens */
@media (min-width: 768px) {
body {
padding: 2rem;
font-size: 18px;
}
}
2. Flexible Layouts
/* Stack on mobile */
section {
width: 100%;
}
/* Side-by-side on desktop */
@media (min-width: 768px) {
section {
width: 48%;
display: inline-block;
}
}
3. Touch-Friendly Targets
button, a {
min-height: 44px; /* Apple's recommended touch target */
padding: 0.75rem 1.5rem;
}
menu li {
padding: 0.75rem 1rem;
margin: 0.5rem 0;
}
4. Responsive Images
img {
max-width: 100%;
height: auto;
}
5. Readable Line Lengths
p {
max-width: 65ch; /* Comfortable reading width */
}
All of this is built into TextFirst.css already.
The Mobile Testing Matrix
TextFirst.css
| Device | Screen | Works? | Notes |
|---|---|---|---|
| iPhone SE | 375px | ✅ | Perfect |
| iPhone 15 | 393px | ✅ | Perfect |
| iPhone 15 Pro Max | 430px | ✅ | Perfect |
| iPad Mini | 768px | ✅ | Perfect |
| iPad Pro | 1024px | ✅ | Perfect |
| Android Small | 360px | ✅ | Perfect |
| Android Large | 412px | ✅ | Perfect |
| Tablet | 768px | ✅ | Perfect |
| Flip Phone | 240px | ✅ | Still works |
| Text Browser | Any | ✅ | Perfect |
Testing required: Open on device Issues found: Zero
Modern React App
| Device | Screen | Works? | Notes |
|---|---|---|---|
| iPhone 15 | 393px | ⚠️ | Sometimes |
| iPhone 15 Pro Max | 430px | ❌ | Layout breaks |
| iPad Mini | 768px | ⚠️ | Weird spacing |
| Android | 360px | ❌ | Buttons overlap |
| Old Android | Any | ❌ | Unsupported |
| Text Browser | Any | ❌ | Blank page |
Testing required: Device lab, BrowserStack, countless hours Issues found: Constantly
The Rounded Corners Evolution
Before iPhone (2007)
.box {
border: 1px solid #ccc;
/* Square corners */
}
After iPhone, Before CSS3
// Create rounded corners with... images
<div class="box">
<img src="corner-tl.png" class="corner-tl">
<img src="corner-tr.png" class="corner-tr">
<img src="corner-bl.png" class="corner-bl">
<img src="corner-br.png" class="corner-br">
<div class="content">...</div>
</div>
4 images for rounded corners!
CSS3 (2010)
.box {
border-radius: 10px;
-webkit-border-radius: 10px;
-moz-border-radius: 10px;
}
Now (2025)
.box {
border-radius: 10px;
}
Just works. All browsers support it.
Lesson: Wait for standards. Don't hack with images/JavaScript.
The Shadow Evolution
Before CSS3
<!-- Shadow using images -->
<div class="shadow-wrapper">
<img src="shadow-left.png" class="shadow-left">
<div class="content">...</div>
<img src="shadow-right.png" class="shadow-right">
<img src="shadow-bottom.png" class="shadow-bottom">
</div>
CSS3
.box {
box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-webkit-box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}
Now
.box {
box-shadow: 0 2px 4px rgba(0,0,0,0.1);
}
Same lesson: Standards catch up. Be patient.
The TextFirst.css Mobile Philosophy
1. Content First
Mobile: Content visible, functional Desktop: Same content, enhanced layout
2. Progressive Enhancement
Small screen: Single column, stacked Large screen: Multi-column, side-by-side
3. Touch-Friendly by Default
All interactive elements:
- Big enough to tap (44px minimum)
- Spaced apart (no accidental taps)
- Visual feedback on interaction
4. No JavaScript Required
Everything works without JavaScript:
- Navigation
- Forms
- Content display
- Collapsible sections (using
<details>)
5. Fast Loading
- 15 KB CSS total
- No JavaScript downloads
- No framework overhead
- Instant rendering
Comparison: Building a Mobile-Friendly Site
The Modern Way
# Install framework
npm install react react-dom next.js
# Install UI library
npm install @mui/material @emotion/react @emotion/styled
# Install responsive utilities
npm install react-responsive
# Configure build
# Write next.config.js
# Write babel.config.js
# Write component
import { useMediaQuery } from 'react-responsive';
const MyComponent = () => {
const isMobile = useMediaQuery({ maxWidth: 767 });
return (
<div className={isMobile ? 'mobile-view' : 'desktop-view'}>
{isMobile ? <MobileNav /> : <DesktopNav />}
</div>
);
};
# Build
npm run build
# Deploy 5 MB bundle
Time: 40 hours Bundle size: 5 MB Works on: Modern mobile browsers (maybe)
The TextFirst.css Way
<!DOCTYPE html>
<html>
<head>
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="textfirst.css">
</head>
<body>
<nav>
<menu type="numbered">
<li><a href="/">Home</a></li>
<li><a href="/about">About</a></li>
</menu>
</nav>
<article>
<h1>Welcome</h1>
<p>Content works on all devices.</p>
</article>
</body>
</html>
Time: 30 minutes File size: 16 KB Works on: Every device ever made
The Wake-Up Call
2010 responsive design SOLVED mobile web.
Then we spent 15 years:
- Making it complicated
- Adding frameworks
- Requiring build tools
- Breaking compatibility
- Losing semantic HTML
For what benefit?
Rounded corners? (CSS3 has them) Shadows? (CSS3 has them) Flexible layouts? (Flexbox and Grid exist) Touch events? (Click events work)
We solved problems that weren't problems.
The Solution
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="textfirst.css">
That's it. That's all you need for mobile.
Works on:
- Every smartphone
- Every tablet
- Every desktop
- Every text browser
- Every screen reader
- Every device that will ever exist
Because it's built on standards that won't change.
Conclusion
Mobile web history:
- Started simple (viewport + media queries)
- Got complicated (frameworks, native apps, PWAs)
- Back to simple (TextFirst.css + responsive design)
Same pattern as desktop web.
Same solution: Semantic HTML + Standards-based CSS
"The mobile web was solved in 2010. We just forgot." - Ethan Marcotte (probably)
"Basic HTML and CSS works on Safari and Firefox. Funny." - User, 2025
"It works on mobile too. Even funnier." - Same user, 2025