Good bones and road grit.

No JS

Pages that work before scripts arrive, after scripts fail, and when scripts were never invited.

  • What the shoulder taught us

    What the shoulder taught us

    The first rule of Dirtbag was simple enough to write on the back of a gas receipt:

    Keep it small.

    No build step. No theme JavaScript. No stylesheet file pretending to be a lifestyle brand. No remote font with a passport. Plain pages, visible links, feeds, comments, and enough road grit to make the thing feel owned by a person instead of a launch committee.

    Then the theme went out for a drive and came back with better rules.

    1. Slogans leak

    “No JS” sounds clean until you look at an actual WordPress page. Core blocks are not cardboard cutouts. Navigation has to open. An overlay has to close. A lightbox has to trap attention without trapping people. Enhanced pagination still has to be pagination when the enhancement quits.

    The old slogan was pointing in the right direction, but it was too austere for the machinery underneath it.

    It’s amazing how much you can do without JS or CSS in a WordPress theme — without bringing in any extra CSS and JS in the time, that is. There’s no getting around either when you’re building with WordPress, but you’ll learn a lot if try to strip down to the simplest starting point.

    The honest truth is duller and stronger, but it’s not great for slogans: Dirtbag does not add its own front-end JavaScript dependency. Dirtbag does not enqueue its own stylesheet file. WordPress core may still bring CSS and JavaScript when core blocks need them. The browser may still do browser work. The document still has to stand when the extras fall away.

    That sentence will not fit on a bumpsticker, sadly.

    2. Core has weight

    Using core is not the same as using nothing.

    theme.json becomes CSS. Core block support becomes markup and styles. The Interactivity API is JavaScript, even when it arrives as an OEM part from WordPress instead of an aftermarket box from the parts store.

    That does not make it bad. It makes it reliable.

    The lesson is not “never use it.” The lesson is “name the owner.” If WordPress core owns the behavior and the fallback is a plain link, button, image, or document, the part might earn its keep. If Dirtbag has to import a second runtime, invent a private convention, or explain why the page is useless until hydration, the truck is overloaded.

    3. Exports lie in small ways

    The Site Editor is useful, but it is far from perfect. Exported templates can come back with local URLs, hard-coded theme slugs, or odd block bindings stuck to the bumper. Seed content can carry yesterday’s idea after today’s philosophy changed.

    So we learned to treat exports like parts from a swap meet: inspect them before installation.

    The package check is not glamour work. It looks for stale local addresses, broken block comments, bad nesting, and things that should have been cleaned before release. That is exactly the kind of boring tool a small theme needs.

    Not a build system. Not a dashboard. A flashlight!

    4. Accessibility is where philosophy pays rent

    A plain theme can still fail people.

    A caption can sit in a scrollable region that keyboard users cannot reach. A menu can look simple and still mishandle focus. A clever visual shortcut can flatten the document for somebody reading it a different way.

    That is why “we did not write the JavaScript” is not a release gate. It is trivia. The gate is whether the page works with a keyboard, a screen reader, a small viewport, slow patience, and scripts that may or may not arrive.

    Plain is not automatically accessible. Plain is just easier to audit when you have not buried the page under theater.

    5. The page is the product

    The best thing we learned is also the oldest thing on the web: the page is already the product.

    Not the framework. Not the tooling story. Not the perfect screenshot. Not the promise that a future version might carry a shinier library if the vibes are right.

    A page with a title, a date, a byline, some links, a feed, comments, and honest markup is not a fallback. It is the thing.

    Everything else is a part in the glovebox. Useful sometimes. Dead weight often. Worth carrying only when it gets the page farther down the road without leaving anybody in the ditch.

  • OEM parts, not aftermarket chrome

    OEM parts, not aftermarket chrome

    Dirtbag used to be easy to explain at the counter:

    No theme JavaScript. No theme stylesheet. No build step. Cash only. Coffee burned since 6 a.m.

    That is still mostly true, but mostly is where the honest work starts.

    WordPress is not an empty field. It is a machine with a lot of factory parts already bolted to the frame. Core blocks bring layout styles. Global styles turn theme.json into CSS. The Navigation block can bring an overlay. Query pagination can be enhanced. Images can open in a lightbox. Under some of that work sits the WordPress Interactivity API — Preact and signals, packed by core, riding in the same parts bin as the blocks.

    So the better Dirtbag line is this:

    Dirtbag does not ship a theme-owned front-end JavaScript dependency. It does not enqueue a theme stylesheet file. It uses the browser first, WordPress core second, and aftermarket chrome only after the job has a name and the fallback still works.

    That is less pure and more useful.

    The browser is already a tool

    A link already goes somewhere. A form already submits. A heading already divides the page. A list already lists. A table already needs headers, rows, and a caption before anybody starts making it “interactive.”

    Most websites do not need a tiny app pretending to be a document. They need the document to stop being embarrassed about itself.

    Dirtbag starts there. Let the browser carry what the browser was born carrying. Use plain links. Use feeds. Use comments. Use details and summary when a disclosure is enough. Keep the page useful before the script arrives, after the script chokes, and when the script was never invited.

    Core is the OEM part

    There is a difference between using the part that came with the truck and ordering a glowing spoiler from a catalogue.

    When a WordPress core block needs its own behavior to open, close, paginate, or keep an interface usable, that is not Dirtbag sneaking in a private framework. It is core doing core work. The cost is still real. The JavaScript is still in the browser. The accessibility still has to hold. But the dependency belongs to the platform we already chose.

    That is why the Interactivity API changes the conversation. If a core enhancement already uses the core runtime, Dirtbag should not pretend Alpine, Reef, VanJS, or some other handy little hitchhiker is the first stop. The first stop is still no runtime. The second stop is the core runtime already under the hood.

    Only after that do we talk about bringing another tool.

    No theme JavaScript is not no responsibility

    This is the part where the bumper sticker gets peeled off.

    “No theme JavaScript” does not mean “no JavaScript ever executes.” It does not mean the mobile menu is somebody else’s problem. It does not mean enhanced pagination gets a hall pass because core wrote the script. If Dirtbag chooses the block or opts into the enhancement, Dirtbag owns the test.

    Can you tab through it? Can you close it with the keyboard? Does the link still work when the enhancement does not? Does the image remain an image without the lightbox? Does the page still read like a page?

    If not, the OEM part did not earn the ride.

    The rule for the glovebox

    Keep the glovebox small.

    Carry HTML. Carry feeds. Carry visible links. Carry theme.json. Carry core blocks. Carry core behavior when it is already the right part for the job.

    Do not carry a second runtime because the first one was fashionable last week. Do not add a clever state machine to avoid writing a clearer document. Do not turn a small site into a kit car with seven manufacturers stamped under the hood.

    Dirtbag is not anti-JavaScript the way a sign in a diner is anti-fun. Dirtbag is anti-freight. Every part has to earn its weight, and the page has to get home if that part falls off on the shoulder.

  • Idling near the gravel pit

    Idling near the gravel pit

    Rural speed, shed talk, hard chirps, and the suspicion that a simple job should stay simple.

    The truck is idling in the drive, the coffee is gas-station warm, and your site is finally doing its basic tasks without dressing them up as a product launch.

    Dirtbag is here for plain posts, visible links, comments, feeds, OPML, XFN, microformats, web-safe colours, and just enough CSS to keep the text from hugging the ditch.

    • RSS is visible.
    • Comments are open.
    • The blogroll has an OPML file.
    • The only JavaScript is WordPress core’s own — the theme’s stays in the glovebox.

    Somewhere under the hood, there is a rockabilly backbeat: slap bass, cheap chrome, and a rhythm section made of loose bolts.

    Outside, the sound of car tires coming down your gravel road…

    If a page can be a page, let it be a page.

    And get on with the writing!

  • Field notes from the shoulder

    Field notes from the shoulder

    A dispatch from the edge of the road.

    (more…)
  • Tools that earn their keep

    Tools that earn their keep

    The best tools are boring, visible, and hard to break.

    If it needs a webpack config, it might not belong in the kit.

    ToolWhy
    NotebookWorks without power.
    KnifeSolves packaging.
    RagAlways useful.
    Tools and reasons to carry them