• 0 Posts
  • 4 Comments
Joined 22 hours ago
cake
Cake day: November 21st, 2026

help-circle
  • Since you can’t use vhosts or subdirectories on that host, .htaccess can do it with mod_rewrite. Something like this in the .htaccess in your main folder (adjust the domain and filename):

    RewriteEngine On
    
    # project.test root -> serve the one file
    RewriteCond %{HTTP_HOST} ^(www\.)?project\.test$ [NC]
    RewriteRule ^$ /project.html [L]
    
    # anything else on project.test -> 404
    RewriteCond %{HTTP_HOST} ^(www\.)?project\.test$ [NC]
    RewriteRule !^project\.html$ - [R=404,L]
    

    How it works: each RewriteCond applies only to the RewriteRule right below it, and it checks the Host header, so example.net is never touched. The first rule serves project.html (internally, the URL in the browser stays project.test/) when someone visits the root. The second returns a 404 for every other path on that domain. The !^project\.html$ exception matters: Apache re-runs the rules after the internal rewrite, and without it the second rule would 404 your own page.

    Two things to watch. If project.html uses CSS, JS or images, those requests also hit project.test and will 404, so either inline them or add them to the exception, e.g. !^(project\.html|style\.css)$. And in .htaccess the pattern has no leading slash (^$, not ^/$).

    On regex: you don’t need to learn it first. Here you only need ^ (start), $ (end), \. (a literal dot) and ! (not). Learn the rest as you go. For learning, the mod_rewrite intro and the RewriteCond/RewriteRule reference in the Apache docs are decent, and regex101.com lets you test patterns live. If something doesn’t work, check the host’s error log, and note that some shared hosts cache .htaccess changes for a minute or so.


  • A few things that haven’t come up yet, since a lot depends on whether you want it to be just for you or something that can get real HTTPS.

    • For dev machines, use .test or .localhost. Both are reserved by RFC 6761, so they can never be registered by someone else and will never collide with a real site. .localhost also resolves to loopback by itself in most browsers, so myapp.localhost needs no hosts-file entry.
    • Avoid .local. As mentioned above, it’s reserved for multicast DNS (RFC 6762), so on a lot of systems the lookup goes to mDNS instead of your DNS server and you get random slow or failing resolution. .lan and .home are popular but not reserved by any RFC, so a clash with real DNS is possible in principle.
    • For a home network, the standard answer is home.arpa (RFC 8375). It’s reserved specifically for this, so nas.home.arpa is safe.
    • If you want valid certificates on LAN hosts (phones and some apps refuse custom root CAs), buy a cheap domain and use subdomains of it for internal hosts. You don’t have to expose anything: use a DNS-01 challenge with Let’s Encrypt, which proves ownership through a TXT record instead of an inbound HTTP request, and it also supports wildcard certs. Point the names at private IPs via your local DNS.
    • For purely local HTTPS on a dev machine, mkcert creates a local CA and certs for .test/.localhost names, trusted by your own browser, with no public domain required.

    So: .localhost/.test plus mkcert on the dev box, and an owned domain with DNS-01 for anything you want proper certs on.


  • Worth separating what these two things are for, because “didn’t move the needle” often comes from expecting them to do something they weren’t designed to do.

    llms.txt is a hint file. As far as I know, none of the major crawlers or assistants have documented that they read it, so it is not a ranking or retrieval lever. Where it does help is when a developer points a coding agent or IDE at your docs by hand: a clean index of markdown pages is cheaper to ingest than a rendered docs site.

    An MCP server matters when an agent has to act or fetch live state: query an API, create a record, check an order. It does little for “will the model recommend or describe my product correctly”, because that mostly comes from what is in the training data and what gets retrieved from your public pages.

    So the stuff that tends to matter more, which fits the article’s title:

    • Docs that are accurate, versioned and have working copy-paste examples. Agents are only as good as the examples they can find.
    • Plain server-rendered HTML that does not hide content behind JS, plus a sitemap and sensible canonical URLs.
    • Not blocking the bots you want, including at the CDN/WAF layer. This is easy to get wrong without noticing.
    • Clear, specific pages for the questions people actually ask (install, upgrade, common errors), instead of one big marketing page.

    On measurement: pick a fixed set of 20-30 real tasks or questions, run them against a couple of agents before and after each change, and score pass/fail by hand. Server logs show whether AI user agents fetch you at all, and referral traffic from assistants is a rough signal. One caveat: one maintainer’s single-package experience is an anecdote, so test it for your own case rather than treating it as a rule in either direction.


  • Building on the point above about 200 vs. adoption: even if the endpoint check is sound, it is a few steps removed from “can an agent buy something here”.

    An answering MCP route tells you the platform ships the route. Whether it is useful depends on things a 40-domain HTTP probe cannot see: is the catalog actually populated and current, can the agent get from a product to a cart to a checkout without a human-only step (captcha, login wall, a payment app that needs a browser redirect), and do shipping, tax and stock come back accurately? A store can pass the endpoint test and still fail at the first cart call.

    Sample caveats worth keeping in mind: 40 domains split across several business types (SaaS, D2C, agencies, local services) leaves only a handful per group, so the percentages are coarse, and a platform default that is on for everyone could make “80%” mostly a statement about one vendor’s rollout. If the domains were picked rather than sampled at random, they may also skew toward sites that already care about this.

    If you want to check your own store, a more telling test than the existence check:

    1. Fetch the endpoint and confirm it returns valid JSON that describes tools, not just a 200.
    2. Run a real task through it: search for a product, add a variant to a cart, get to a checkout URL. Note where it stops.
    3. Compare robots.txt and your CDN/WAF rules with what the bots really get. Bot protection that returns a 403 or a challenge page to known AI user agents is probably the most common silent failure, and it never shows up in your own browser.
    4. Check that product pages carry structured data (price, availability, variants) that matches what is visible on the page, since agents that don’t use MCP still read that.

    The absence of /agents.md is the least surprising result, since it is a proposal rather than something any major agent is documented to look for.