Pixel

Pixel Updates & Events

Server Updates & Events

Announcements

The Hidden Cost of Uncapped AI Agent Loops

DEV Community

An AI agent with no step limit stops when its context window is full. On GPT-5.6 that's $160 for one run.

The first agent most of us write is a while True loop. Ask the model what to do, run the tool it picks, append the result to the history, ask again. It stops when the model says "done". Usually it does. Sometimes it doesn't: it reads the same file again, retries a failing test forever, or keeps searching for something that isn't there. If you have no step limit, that loop still ends eventually. It ends when the history no longer fits into the model. I simulated how much that one run costs, and the number is set mostly by the size of the context window. A few words first A token is a chunk of text the model reads as one piece; APIs bill per million of them. Input tokens are what you send, output tokens are what the model writes back, and output is priced higher. The context window is the most tokens one request can hold; a request that's bigger is rejected. An agent loop is code that calls the model repeatedly, letting it choose tools, and sends the full history with every call, because the API itself remembers nothing between calls. A step cap is a hard limit on how many times the loop may go around. The setup Every step resends everything so far and adds two things: the model's tool call, which I set at 200 output tokens, and the tool's result. For the result I measured a typical action, "read 100 lines of a file", by cutting four Python standard library modules into 100-line chunks and counting them with tiktoken (o200k_base, the encoding behind current GPT models). The median chunk was 802 tokens, so I used 800. The loop starts with 4,000 tokens of system prompt, tool descriptions and task. So each step makes the next request 1,000 tokens bigger. The loop runs until the next request plus its answer would overflow the window. Prices are official list prices from the catalog of the LLM gateway I work on, snapshot of 12 November 2026, with no discounts applied. Model (window) Steps until full Runaway run With a 25-step cap GPT-5.6 mini (400K) 396 $16.05 $0.09 GPT-5.6 (400K) 396 $160.54 $0.86 Claude Haiku 5.5 (1M) 996 $50.05 $0.04 Claude Sonnet 5.5 (1M) 996 $1,000.98 $0.85 Claude Opus 5.5 (1M) 996 $2,001.96 $1.70 On GPT-5.6 the runaway run costs 187 times what a capped one does. On the 1M-token models it's 1,178 times. The last step alone on Sonnet 5.5 costs $2, more than the whole capped run. Why the window sets the price Step n sends about n thousand tokens, so the total is 1 + 2 + 3 + … up to the last step. That sum grows with the square of the number of steps, and the number of steps is the window divided by the growth per step. Put together, a runaway run sends roughly window² ÷ (2 × tokens added per step) input tokens: 400,000² ÷ 2,000 = 80 million on GPT-5.6, almost exactly the 79.8 million the simulation counted. That's why a bigger window is a bigger risk. At the same $2/$12 price, I ran the loop with three window sizes: 200K costs $40.26, 400K costs $160.54, 1M costs $1,001.38. Doubling the window made the run 4.0 times more expensive; 2.5 times the window made it 6.2 times more. A model upgrade that "only" raises the window from 200K to 1M multiplies your worst case by 25 without touching the price per token. The fix is two counters Count steps, and count dollars from the usage field every response already returns. Here is the guard, written for OpenAI-style responses: PRICE_IN, PRICE_OUT = 2.00, 12.00 # $ per 1M tokens, your model's list price
MAX_STEPS, MAX_USD = 25, 1.00

def run_agent(client, model, messages, tools, execute_tool):
spent = 0.0
for step in range(MAX_STEPS):
r = client.chat.completions.create(model=model, messages=messages, tools=tools)
u = r.usage
spent += (u.prompt_tokens * PRICE_IN + u.completion_tokens * PRICE_OUT) / 1e6
msg = r.choices[0].message
messages.append(msg)
if not msg.tool_calls:
return msg.content, spent
if spent >= MAX_USD:
raise RuntimeError(f"budget hit after {step + 1} steps: ${spent:...

Powered by Readybot.io

The Hidden Cost of Uncapped AI Agent Loops

Platform Engineering 2026: IDP Tools and Trends

DEV Community

Platform Engineering 2026: Internal Developer Platforms – Between Open Source and SaaS

Platform engineering has evolved over the past two years from a conference buzzword into a strategic discipline. At its core, it’s about a simple question: How do development teams get a self-service infrastructure platform without every team having to become a Kubernetes expert? The answer is an Internal Developer Platform (IDP) – and in 2026 the market is more dynamic than ever. CNCF Technology Radar: The Data The CNCF Q1 2026 Technology Radar, published in March 2026 based on a survey of over 400 professional developers, paints a sobering picture: only 28 percent of organizations have a dedicated platform engineering team. The majority – 41 percent – rely on loose multi-team collaboration, which in practice means the platform remains a shared side project without a fixed owner. 35 percent report a hybrid platform that combines existing developer portals with specialized AI tools. On the tooling side, the picture is clearer. Backstage, Helm and k9s are in the Adopt status for application delivery. Helm achieves the highest maturity rating: 94 percent of developers gave four or five stars for reliability. GitHub Actions scores 91 percent recommendation, and cert-manager 87 percent for stability. Backstage: The Market Leader Backstage, open-sourced by Spotify in 2020 and donated to the CNCF, remains the gold standard. With over 34,000 GitHub stars and more than 200 community plugins, it forms the backbone of most IDP strategies. The catch: Backstage is a framework, not a finished product. Every team that uses it operates its own React/Node application, writes its own plugins, and keeps up with the release pace of versions like v1.55.3 (September 2026). The total cost consideration puts the supposedly free license into perspective. Third-party analyses estimate the actual annual cost for a medium-sized Backstage installation at around $150,000 – driven by engineering time for integration, plugin development, and operations. So if you’re comparing Backstage against a SaaS alternative, you shouldn’t compare with $0, but with that figure. The Commercial Competition: Port, Cortex, and OpsLevel Against the open-source option, three commercial providers have positioned themselves, gaining massive maturity in 2025 and 2026. Port has evolved from managed Backstage hosting into an “Agentic SDLC” company. The launch of Port AI Builder in July 2026, a natural-language interface for agentic workflows, marks the most significant AI push in this segment so far. Pricing is transparent: Basic from $30 per seat per month (up to 50 seats), Standard from $40 (up to 200 seats). Cortex focuses on scorecards and engineering leadership. Instead of starting with a catalog interface, Cortex builds around evaluating services against maturity criteria – security patching, test coverage, on-call readiness. The entry price is around $65 per user per month (Amazon Marketplace reference for 50 users: $39,000 annually). OpsLevel competes directly with Cortex but differentiates through deep CI/CD and deployment integration. Instead of initiative tracking, it focuses on supply chain metrics: build times, deployment frequency, and change failure rate. The Build vs. Buy Dilemma Platform engineering is not a pure technology decision. If you build, you save the license but pay in engineering time. A rough three-year calculation for a 150-person team shows: Backstage (self-hosted) costs cumulatively about $390,000, Port (Standard tier) $216,000, Cortex (Marketplace reference) $351,000. Port’s published prices give the cheapest three-year outlook in the model – though without considering migration costs if you switch later. However, the truly critical factor is not the price, but the internal organization. If you don’t have a dedicated platform team, Backstage is often not an option – operating your own React/Node application plus plugin maintenance overtaxes multi-team structures. Commercial offerings provide faster time-to-value here, bought at the cost of vend...

Powered by Readybot.io

Platform Engineering 2026: IDP Tools and Trends

How to Get Your MCP Server Found on Google

DEV Community

How to make your MCP server show up in Google

You built an MCP server, pushed it to the registry, maybe wrote a GitHub README — and when you search for it, nothing. Or worse: a stale third-party page ranks instead of you. MCP servers are weirdly hard to find in Google, and the reasons are fixable. Here's what actually moves the needle. Why MCP servers are invisible The registry is a JSON feed, not a web page. The official MCP registry is machine-readable. Google indexes pages, and a JSON entry isn't one. GitHub repos rank for the repo name, not intent. Your repo might surface if someone searches your exact name, but not for "MCP server for X" — and external links in a GitHub README are nofollow, so your repo doesn't pass authority to your own site. No dedicated page means nothing to rank. If the only "page" about your server is a registry row and a repo, there's nothing for Google to show for a discovery query. What actually helps 1. Give your server a real, indexable page A landing page or docs page on your own domain, with a clear title and a 100+ word description of what the server does and how to install it. This is the page you want to rank. One page done well beats a thin repo. 2. Write a description that matches how people search Registries and directories pull your description. Write it for a human searching "MCP server for Postgres" or "Stripe MCP server," not for a changelog. Lead with the capability, name the integration, keep it under ~160 characters for the meta description. 3. Get listed where the listing is actually indexable Most MCP directories exist, but many of their pages carry a noindex tag until a listing is claimed or hits a quality bar — so being "listed" isn't the same as being indexed. Check the real page: view source and look for . If it's there, that listing isn't helping you in search. On Serverdex, for example, every server in the registry already has a page, but unclaimed ones are noindex until you claim them. Claiming your listing (free, one GitHub click) flips the page to indexable, adds it to the sitemap, and gives you a dofollow link back to your site — the kind of link that actually helps your own domain rank. 4. Earn a couple of real links A dofollow link from a relevant, indexed page is worth more than ten nofollow mentions. A short dev.to post about your server, a PyPI package with your homepage set, a mention from a blog that covers MCP — those are the links Google counts. GitHub stars and nofollow README badges feel good but do not move search rankings. 5. Don't wait for the registry to do it for you The registry's job is distribution to clients, not SEO. Search visibility is on you: one good page, an honest description, an indexable listing, and a few real links. The quick version One real page on your domain — 100+ words, clear title. A description written for search intent. A listing that is actually indexable (check for noindex). A couple of dofollow links from indexed pages. Ignore nofollow vanity metrics. If you want to check whether your server already has an indexable page — and claim it — the whole registry is searchable at Serverdex.

Powered by Readybot.io

How to Get Your MCP Server Found on Google

Why Notifio’s Comparison Pages Aren’t Real Tables

DEV Community

49 rows of comparison, zero table elements, and 811 words of it carrying five full stops in total

I pulled all 38 pages of notifio.app and counted words and sentences in the visible text, to see where the site's weight actually sits: 36,947 visible words 2,001 sentences 18.5 words per sentence on average thickest page: /terms at 2,440 words thinnest page: /download at 149 words, with /pricing second at 344 That last pair is worth a post of its own some day, because the two pages that have to actually sell something are the two thinnest on the site. But the thing that stopped me was the sentence-length table. The longest sentence on notifio.app, by my splitter, was 202 words. The next three were 191, 168 and 150. The fifth was 141 words and sat in the terms of service, which is where you expect to find a 141-word sentence. The top four were not sentences. They were the comparison tables, and they are not tables. There is no table in the comparison table $ curl -s https://notifio.app/compare/rentbird | grep -c '<table'
0
$ curl -s https://notifio.app/compare/rentbird | grep -c 'role="'
0
No , no , no role="table", no . The side-by-side on all five comparison pages is a CSS grid of div and p elements, 13 grid containers on the page. I counted the rows and their honesty flags last month in 49 rows in our comparison tables, 13 of them say the competitor wins. I counted the argument prose in a required field made us concede on every comparison page. Both times I read the data and never the markup carrying it. Measured per page, taking the text of just the side-by-side section: Page Rows Words in the section Sentence-ending full stops /compare/rentbird 10 196 1 /compare/visualping 11 185 1 /compare/rentslam 10 162 1 /compare/stekkies 10 144 1 /compare/rentola 8 124 1 811 words, 49 rows, and five full stops between them. Each page's single stop is the caption underneath: "Brighter text marks whichever side we think genuinely wins that row, including the rows where it is not us." Flattened, the Rentbird one begins like this: Rentbird Notifio Price Rentbird: €29 for one month, €49 for three Notifio: £20 once, forever What happens when you stop paying Rentbird: Alerts stop Notifio: Nothing, since the licence does not expire The rival's name appears twelve times in the extracted text of a ten-row table. That is not a bug in my extractor. It is two labelling systems in one document. Why it is divs, and why the divs are not lazy // src/app/compare/[target]/page.tsx

 

{target.name}

Notifio

function Cell({ label, value, won }: { label: string; value: string; won: boolean }) {
return (


{${label}:}
{value}


);
}
There are two sets of labels and each is switched off at the breakpoint where the other works. On a wide screen you get a column header row and the per-cell prefixes are display: none. On a phone the header row is display: none and each cell introduces itself, "Rentbird: €29 for one month", which is the only way a three-column row survives being stacked vertically. 98 of those hidden prefixes exist across the five pages. And the accessibility of that is better than I expected when I started writing this. Tailwind's hidden is display: none, and display: none is hidden from assistive technology, not just from eyes. So a screen reader at desktop width hears the column header and no prefix; at phone width it hears the prefix and no header. The labels follow the breakpoint. This is not the classic bug where a visually hidden label gets announced on top of a visible one. What is actually lost Two things, and the second one is the one I had not thought about. Table semantics. Without , a screen reader user gets 49 paragraphs in a row. There is no "column 2 of 3", no row navigation, no way to walk down one product's column and hear only its answers. On...

Powered by Readybot.io

Why Notifio’s Comparison Pages Aren’t Real Tables

Migrate from Namespace Runners Without a Cold Cache

DEV Community

Migrate from Namespace runners without a cold cache

Teams that migrate from Namespace runners are almost never leaving because of the hardware, which is good, and almost always underestimate the same thing: Namespace is not only a label, it is a set of drop-in actions and a cache that behaves unlike any other cache in this market. The label change takes a minute and the cache change decides whether the migration reads as neutral or as a regression. The cache behaviour that changes on the way out, and why a new feature branch starts cold afterwards. Behaviour read from both vendors documentation on 2026-09-21. Start with what moves and what does not. The label moves: runs-on is one line and every destination has a size that matches. The workflow steps mostly move untouched, because they are ordinary steps. Three things do not move, and each one is a real edit. The nscloud- actions have to be swapped back for the standard ones. The cache changes scope, from shared to branch-isolated, which is a behavior change with no error attached. And the remote Docker builders that were on by default stop existing, so a workflow that deleted its buildx setup has to get it back. What a runner profile was carrying Namespace attaches its features to a runner profile rather than to individual steps, which is why the label looks so short and the migration is longer than it looks. A job that reads runs-on: namespace-profile-default may be getting a cache volume, a git mirror, a container image cache and a remote Docker builder without any of those appearing in the workflow file. The undo list below is therefore a list of things to look for in the profile as well as in the YAML. Work through it before you change the label, because after you change it the symptoms are all the same symptom: the job is slower and nothing failed. Namespace surface What it did Standard replacement What changes namespace-profile- label Selected the profile and everything attached to it A size label, for example latchkey-small Features attached to the profile stop being implicit nscloud-checkout-action A faster checkout using a git mirror actions/checkout Clone time returns to an ordinary shallow clone nscloud-cache-action A cache volume, shared across branches actions/cache with explicit keys You now write keys, and restores obey branch scope Remote Docker builders, on by default A warm BuildKit builder beside the runner docker/setup-buildx-action plus cache export Layer cache is exported and imported per build Unit-minute billing Charged at max(vCPU, RAM divided by 2) per minute A fixed per-size rate Memory stops costing extra when cores sit idle Namespace surfaces read from its GitHub Actions documentation on 2026-09-21. The unit-minute model, its platform multipliers and the prepaid against overage split are worked through separately in Namespace alternatives; this page assumes you have already decided to leave and is only about the cutover. The cache is the migration This is the change most likely to make a migrated pipeline slower with nothing in the log to explain it. Namespace documents that its cache action does not support manual partitioning: entries are shared across everything using that runner profile, which includes the default branch and every feature branch at once. actions/cache is the opposite by design, restorable only from the branch that wrote the entry or from the default branch. So a workflow that never thought about cache keys was quietly getting cross-branch hits, and on the other side it will not. The fix is not exotic, it is a prefix key and a restore-keys fallback, but it has to be written before the first run rather than discovered from a timing graph a week later. Write the keys so a new branch falls back to the default branch entry, and accept that the first run on a new dependency set is cold. - uses: actions/cache@v4
with:
path: ~/.npm
key: npm-${{ runner.os }}-${{ hashFiles('
/package-lock.json') }}
restore-keys: |
npm-${{ runner.os ...

Powered by Readybot.io*

Migrate from Namespace Runners Without a Cold Cache

Free Sample Files for QA and Upload Testing

DEV Community

A Clean, Ad-Free Resource for Downloading Sample & Dummy Files for QA and Upload Testing

Every time I build a file upload feature, media player, or document parser, I run into the same small annoyance: finding clean test files in specific sizes (like a 100 KB vs. 5 MB vs. 10 MB file) without clicking through sketchy download sites full of fake "Download" buttons and pop-up ads. Recently I came across SampleFilesHub, and it has quickly become a bookmarked tab in my daily dev and QA workflow. Why it's actually useful for developers Zero ads or dark patterns: No signups, no captchas, and no fake download buttons. You pick a format, pick a file size, and click download. Multiple file sizes per format (100 KB to 10 MB): Really handy when you need to test both happy-path uploads (small files) and edge cases like progress bars, chunked uploads, or server payload limits (client_max_body_size / API body limits). 30+ formats organized by category: Sample Images: JPG, PNG (with alpha transparency), WebP, SVG, GIF, and AVIF. Sample Videos: MP4 (360p up to 4K Ultra HD), MOV, WebM, AVI, and MKV. Sample Audio Files: MP3, WAV (uncompressed PCM), OGG, AAC, FLAC, and M4A. Sample Documents: Multi-page PDF files, DOCX, XLSX spreadsheets, PPTX, CSV datasets (up to ~96,000 rows), TXT, and RTF. Archives & Data Payloads: ZIP, TAR, JSON, XML, Markdown, and HTML. Common scenarios where this saves time Testing file upload validators (checking MIME types, magic bytes, and size limits). Benchmarking image optimization pipelines (Sharp, next/image, Cloudflare Images). Testing PDF text extraction, OCR, or AI RAG document chunking. Stress-testing CSV/JSON importers and streaming parsers with 5 MB–10 MB datasets. All files are royalty-free for development, automated E2E tests (Playwright/Cypress), and commercial QA. Link if you want to bookmark it: https://www.samplefileshub.com What tools or utilities do you all keep bookmarked for quick QA and dummy data testing?

Powered by Readybot.io

Free Sample Files for QA and Upload Testing

Confluence Q&A Migration: Export Before You Move

DEV Community

Moving Confluence Q&A to Cloud: export, migration and the Connect deadline

If your team uses a Q&A app inside Confluence, two dates are worth knowing about before you plan anything else: Data Center: Atlassian stopped selling Data Center to new customers on March 30, 2026, and DC goes read-only on March 28, 2029. Most teams will move to Cloud before then. Connect apps: Atlassian's older app framework (Connect) reaches end of support on January 31, 2027. Admins already see "This app might stop working soon" banners on apps that haven't moved to Forge. Q&A content is easy to forget in a migration plan because it isn't pages. Here's what we learned while building a Q&A app for Confluence Cloud. 1. Questions for Confluence on Data Center: export before you switch off Atlassian's own FAQ is clear that Questions for Confluence Cloud has no export. Data Center is different: it has a REST API and documented database queries. REST: GET /rest/questions/1.0/question?limit=700, then GET /rest/questions/1.0/answer/{answerId} per answer Database: the queries in Atlassian's KB article "How to export Confluence Questions data" Turn that into a CSV with one row per question and one row per answer (linked by the question's id), and keep it, whatever tool you pick next. Once the DC instance is gone, so is the only export path. 2. Q&A apps still on Connect: check now Open Manage apps in Confluence admin. If your Q&A app shows the "might stop working" banner, ask the vendor for their Forge plan and an export. Apps keep running after Jan 31, 2027, but only with critical security fixes, so "it still works" is not a plan. We built a free checker that looks up any Marketplace app and tells you whether it is on Forge, moving, or at risk: https://surfaced-srzj.onrender.com/guides/connect-end-of-support?utm_source=devto&utm_campaign=askbase_launch 3. What to look for in a Cloud Q&A tool From reading a few hundred reviews of Confluence Q&A apps, the complaints repeat: Search only matches titles, so answers are hard to find No import or export, so content is locked in No way to stop duplicates, so the same question is asked five times Everyone can answer, even for HR or legal questions where only experts should No way to ask from the page people are actually reading Whatever you pick, test those five. Disclosure I'm on the team that makes Askbase, a Forge-native Q&A app for Confluence Cloud. Version 2.5 (out this week) does CSV/JSON import and export, searches answers, suggests similar questions while you type, lets moderators merge duplicates, can limit who answers, and adds an "Ask a question" box to any page. It's free for up to 10 users. Import guide (including the Data Center path above): https://surfaced-srzj.onrender.com/apps/askbase/import?utm_source=devto&utm_campaign=askbase_launch Marketplace: https://marketplace.atlassian.com/apps/3507606829/askbase-q-a-for-confluence?utm_source=devto&utm_campaign=askbase_launch Questions or migration stories welcome in the comments.

Powered by Readybot.io

Confluence Q&A Migration: Export Before You Move

Auditing Accessibility Trees Across 76 Web Pages

DEV Community

I dumped the accessibility tree of all 76 of our pages: no unnamed controls, one image, and one heading in the wrong place

Most accessibility checks I have written start from the DOM. Count the aria-label attributes, grep for an alt, assert that there is one h1. It is cheap and it is a guess, because the thing a screen reader uses is not the DOM. It is the accessibility tree the browser computes from it, where names come from six possible sources in a fixed order and whole subtrees disappear for reasons that are not visible in the markup. So for Nakodo, which finds creators and local businesses that fit a brand and emails the good fits, I stopped guessing and asked Chrome for the tree itself. All 76 public pages, one Accessibility.getFullAXTree call each, every node aggregated. Here is what came back, and the one thing it found that a DOM grep had been missing for weeks. The method The tree is not available through normal page JavaScript. There is no document.accessibilityTree. You get it from the DevTools protocol, which means driving the browser rather than running a snippet in it: await page.cdp("Accessibility.enable");
const { nodes } = await page.cdp("Accessibility.getFullAXTree");
Each node arrives with a computed role, a computed name with the list of sources that were considered and which one won, a description, a property list (focusable, level, invalid, describedby) and an ignored flag. That last flag is the interesting one: getFullAXTree returns the nodes the browser decided not to expose as well as the ones it did, so you can measure what you are hiding instead of inferring it. If you want to see the same thing by hand rather than by protocol, open DevTools on any page, go to the Elements panel, open the Accessibility pane in the sidebar and tick "Enable full-page accessibility tree". That is the same data with a different front end. The totals Measure Value Pages 76 Nodes returned 60,481 Ignored (not exposed) 5,218, which is 8.6 per cent Exposed 55,263 Exposed nodes carrying a name 43,460 Distinct roles 42 Nodes per page 343 at the lowest, 1,099 at the highest, 827 median The smallest page is the alternatives hub at 343 nodes. The largest is the home page at 1,099, which is also the page with the largest ignored share at 20.9 per cent. Both of those numbers have the same cause, and I will come back to it. Two roles account for more than half of everything: 20,117 InlineTextBox and 14,182 StaticText. Text is what a website is. After that it is 5,084 links, 4,746 list items, 2,740 paragraphs, 662 headings, 648 table cells and a long tail: 334 disclosure triangles, 314 terms with 314 matching definitions, 63 times, 20 figures with 20 captions, 5 tooltips, 3 radios. Finding one: 5,166 controls, every one of them named The audit flagged any node with an interactive role and an empty computed name. The set was 5,084 links, 43 buttons, 36 text boxes and 3 radios, so 5,166 controls across the site. Zero of them have no name. I was braced for a handful. The usual suspects are icon-only buttons, links wrapped round a decorative image, and inputs whose label is a styled div sitting next to them rather than a label. The reason none of those bite here is boring and worth saying out loud: the icon set is only ever used inside a control that already has text, and the one place where an icon stands alone is the small-screen menu trigger, which carries an explicit label:


That is the whole trick. There is no clever labelling system here, no utility that enforces a name. There is just one component for buttons, one for inputs, and a habit of writing the words before the picture. The computed-name sources in the tree confirm it: the overwhelming majority of those 5,166 names come from contents, which is to say from the text that is already visible on the page, not from an attribute somebody remembered to add. Count them yourself on the page with the most controls, the glossary, which has 118 focusable nodes: [...document.querySelectorAll("a, button...

Powered by Readybot.io

Auditing Accessibility Trees Across 76 Web Pages

Munchable Privacy: Account Export and Data Deletion

DEV Community

Our delete route touches seven tables, our export route reads five, and the two it misses hold the only free text we have

Munchable is a barcode scanner for people with gut conditions, and the thing that makes its privacy notice short is that the health data never arrives: the conditions you pick, your sensitivities and your scan history are on the phone, and the verdict is worked out there too. The policy is at munchable.app/privacy, and the sentence it leads with is that we hold an email address, a subscription record and any labels you contributed. Two route handlers have to make that sentence checkable: one that hands you everything we hold, and one that erases it. They live in sibling folders, they were written months apart, and they disagree about the schema. The export, in full GET /api/export-account is five queries in parallel and one JSON response. const [ent, consent, rewards, contributions, feedback] = await Promise.all([
db.select().from(entitlements).where(eq(entitlements.userId, uid)).limit(1),
db.select().from(userConsent).where(eq(userConsent.userId, uid)).limit(1),
db.select().from(contributionRewards).where(eq(contributionRewards.userId, uid)),
db.select({ barcode: ..., ingredientsText: ..., createdAt: ... })
.from(catalogProductRevisions)
.where(eq(catalogProductRevisions.contributorId, uid)),
db.select().from(catalogProductFeedback).where(eq(catalogProductFeedback.userId, uid)),
]);
It answers 401 to a signed-out caller and to an anonymous session, serialises with JSON.stringify(payload, null, 2) because a human is going to open it, and sets a content-disposition so it lands as a file rather than a wall of text. The field I want to point at is not a table. It is this: note: 'Your conditions, sensitivities, and scan history are stored only on your device and are never sent to our servers, so they are not part of this export.',
An export of almost nothing looks broken. Someone who scans twenty products a week opens this file, sees a subscription row and two contributions, and reasonably concludes the export is incomplete. So part of the payload's job is to explain its own smallness, in the file, where someone reading the file will see it. Our privacy notice says the same thing, but a notice is not what lands in the Downloads folder. The erasure, and the list it uses POST /api/delete-account is a different shape: cancel the Stripe subscription, then one transaction, then delete the identity. await tx.delete(contributionRewards).where(...);
await tx.delete(catalogProductFeedback).where(...);
await tx.update(catalogProductRevisions).set({ contributorId: DELETED_CONTRIBUTOR }).where(...);
await tx.delete(userConsent).where(...);
await tx.delete(entitlements).where(...);
await tx.delete(supportMessages).where(inArray(supportMessages.ticketId, / subquery /));
await tx.delete(supportTickets).where(...);
Seven tables. Six deletes and one update: contributed revisions are re-pointed at a fixed sentinel id rather than removed, because the catalogue rows that reference them are not personal data and should not vanish from other people's app when one contributor leaves. The route also refuses to start if it cannot finish. Without the Supabase service-role key it cannot delete the identity itself, so it answers 501 rather than deleting the rows and leaving the login, which would be a half-erasure that returns 200. The diff between the two lists Side by side: table erased exported
entitlements yes yes
user_consent yes yes
contribution_rewards yes yes
catalog.product_revisions anon 3 of 18 columns
catalog.product_feedback yes yes
support_tickets yes NO
support_messages yes NO
The two tables the export does not read are the two the erasure route is most emphatic about. Its own comment: // Support history goes with the account. A ticket body is whatever the
// person typed, so it is the most sensitive free text Munchable holds and
// erasure has to take it.
One route calls it the most sensitive free tex...

Powered by Readybot.io

Munchable Privacy: Account Export and Data Deletion

Locale vs. Language: A Website Localization Audit

DEV Community

Our site formats money in 24 locales and declares one language, and 14 of those locales are languages we have no words in

Notifio is a desktop app that watches rental search pages and emails you when a new listing appears. The market for that is a person hunting for a room in Amsterdam, Berlin or Madrid, and the site reflects it: fifteen pages about specific rental portals, grouped into six regional sections on /alerts with headings reading Netherlands, United Kingdom, Europe and international, Germany, Spain and southern Europe, Marketplaces. The site also charges each visitor in their own currency, which I have written about from the payments side in three of our 24 currencies are written without decimals and two of our pages tell the browser tab £20 and the visitor €24.99. What I had never done is look at the two halves together: what the site knows about the visitor's locale, against what it tells the browser about its own language. The markup side of the census 38 pages fetched from the live site: $ grep -o ']lang="[^"]"' pages/.html | grep -o 'lang="[^"]"' | sort | uniq -c
38 lang="en"
$ grep -c 'hreflang=' pages/.html | grep -v ':0'
$ grep -c 'dir="' pages/
.html | grep -v ':0'
38 of 38 pages declare lang="en" 0 hreflang links 0 dir attributes, anywhere, on any element 0 inline lang attributes on any element other than 38 of 38 pages carry exactly one canonical link Nothing wrong with any of that for a monolingual site. The site is monolingual. Hold that thought. The data side of the census // server/src/lib/pricing/display-currency.ts
eur: { code: "EUR", locale: "en-IE", rate: 1.1696 },
chf: { code: "CHF", locale: "de-CH", rate: 1.0981 },
isk: { code: "ISK", locale: "is-IS", rate: 166.32 },
huf: { code: "HUF", locale: "hu-HU", rate: 423.31 },
ils: { code: "ILS", locale: "he-IL", rate: 4.0016 },
24 currencies 58 country codes mapped onto them, resolved per request from x-vercel-ip-country 24 distinct BCP 47 locales, one per currency of those, 10 are English variants: en-GB, en-IE, en-US, en-CA, en-AU, en-NZ, en-IN, en-SG, en-HK, en-ZA and 14 are not: de-CH, sv-SE, nb-NO, da-DK, is-IS, pl-PL, cs-CZ, hu-HU, ro-RO, tr-TR, es-MX, pt-BR, ja-JP, he-IL So the site is carrying enough locale knowledge to write a price the way a reader in Reykjavik, Budapest or Tel Aviv writes it, on pages that have never contained a word of Icelandic, Hungarian or Hebrew. The locale is passed to Intl.NumberFormat and nowhere else. It never reaches the document. The euro is formatted in English This is the detail that made me want to write this up. 27 of the 58 country codes map to eur. That bucket is the Netherlands, Germany, Spain, Italy, France, Ireland and twenty-one others, and it includes every country whose rental portals the site has pages about. Its locale is en-IE. en-IE €24.99
nl-NL € 24,99
de-DE 24,99 €
es-ES 24,99 €
A Dutch visitor to /pricing is shown €24.99. Every Dutch site they have ever bought anything from wrote it € 24,99: symbol, space, comma decimal. The number is right, the currency is right, the punctuation is Irish. I want to be fair to the decision, because there is one. Picking en-IE for the euro means one entry in the table instead of twenty-seven, it keeps the decimal separator the same as every other price on an English-language page, and a page that writes "€24.99 once" in one sentence and "24,99 €" in the next looks broken rather than localised. A single euro locale is the only option that does not require deciding which of twenty-seven conventions wins. But it is still a choice nobody wrote down, and the reason I know it was not deliberate is the locale list it sits in. If formatting natively mattered, en-IE would be wrong. If it did not matter, is-IS and hu-HU would not be there. Two invisible characters The Hebrew entry is the one that goes furthest past what the document can support: $ node -e 'console.log(JSON.stringify(new Intl.NumberFormat("he-IL",
{style:"currency",currency:"ILS"}).format(109)))'
"‏109.00 ‏₪"
Those two marks before the digits and before the shekel sign are U+200F RIGHT...

Powered by Readybot.io

Locale vs. Language: A Website Localization Audit

AER-1 Conformance: 3 Implementation Traps

DEV Community

AER-1 in production: 3 things implementers got wrong on the first try

Your implementation passes every test you wrote. Then you run it against the public conformance corpus and it disagrees on a handful of vectors, and the disagreements look like the spec contradicting itself. That is the normal first week with AER-1. The corpus is 143 vectors and 146 checks, frozen, and conformance means byte-identical verdicts to the reference runners, not verdicts that feel right. Almost everyone who has implemented the draft hit the same three traps on the first try. Two of them were surfaced in public this week by an outside team, probityai, who ran the kit, published what they found, and were right about the tension in both cases. The resolutions are now in the errata for draft -26. Here is what went wrong, and the rule that settles each one. 1. Failing receipts that were never required to carry metadata_hash The symptom: your verifier rejects 0.4 receipts that have no metadata_hash, because Section 6 says a 0.4 receipt without it MUST fail. Then the corpus hands you ten receipts in the valid set with no metadata_hash at all, and your verifier fails the conformance run instead. Both texts are real. Table 1 marks metadata_hash "Cond.": required when receipt_schema_version is "0.4" or later, and a verifier MUST recompute and compare it whenever present. The Section 6 sentence governs the metadata-binding claim, not the core verdict. The reading that fits the whole draft: A producer at 0.4 or later MUST emit metadata_hash. The reference producer does. A verifier MUST recompute it when it is present. A mismatch fails. Its absence is not a failure. The receipt is scored on form, output commitment, version agreement, and provenance binding, and the absence stays visible in the report. What you must never do is report the metadata as bound when the member is not there. If you are a consumer who needs tamper-evident metadata, require the member under your profile and reject its absence there (Section 13). The trap is reading one MUST in isolation. The draft's conformance bar is the corpus plus the reference runners, and both pinned 0.4 shapes, with and without the member, are deliberate. 2. Accepting 5.0 as an integer The symptom: a chain commitment says entry_count: 5.0 over a five-entry timeline. It looks like the same number. The corpus calls the vector invalid, and your verifier, which compared values, called it fine. The difference is what happens to the value next. seq, the member Section 7.1 defines with almost the same words, is canonicalized into integer form before it feeds the entry digest, so 1 and 1.0 serialize identically ("1, never 1.0") and both are accepted. entry_count is never canonicalized. It is a recorded member of a standalone commitment artifact, compared exactly as recorded. For a member like that, "a JSON number with an integer value" is read under the draft's form discipline: encode it as a JSON integer, or the commitment check fails closed. Producers: never emit an integer-valued float for a count. Verifiers: a mistyped member is a failed check, not a rounding opportunity. Run locally, the reference runner rejects the 5.0 vector with "commitment entry_count is not an integer" and passes the identical commitment written with 5. The encoding is the only defect. 3. Hashing the string you see instead of the bytes that were sent The symptom: your hashes agree with your own test fixtures and disagree with everyone else's on any receipt whose content is not plain ASCII. Unicode gives you two byte sequences for what looks like one string. An accented character can be stored as a single code point (NFC) or as a base character plus a combining mark (NFD). On screen they are identical. To SHA-256 they are different inputs, so two honest implementations, each hashing "the same" text, produce different commitments, and each concludes the other one is broken. The fix is to decide the form before the hash, not after the argument: canonical bytes are computed over one fixed normalization form, ever...

Powered by Readybot.io

AER-1 Conformance: 3 Implementation Traps

SEO Audit: 991 Pages, Zero Duplicate Metadata

DEV Community

I measured the title and description of all 991 of our pages: 991 distinct, none over budget, and the tests say 47, 48, 59 and 60

CogniPrep publishes 991 pages. Most of them are generated from registries rather than hand-authored one by one, which is the arrangement that normally produces duplicate titles and descriptions at scale. So I fetched every URL in our own sitemap and parsed the head of each one. 991 URLs, 991 answered 200

titles 991 distinct 25 to 60 chars mean 52.6
descriptions 991 distinct 104 to 159 chars mean 146.8
Zero duplicates on either field, zero titles over 60, zero descriptions over 160, and nothing under 104 characters either. I did not expect that, and the interesting part turned out to be why it happened, because it is not the tests. Why the ceiling is exactly 60 The root layout owns a title template: title: {
default: 'CogniPrep - Psychometric Test Practice',
template: '%s | CogniPrep',
},
| CogniPrep is 12 characters. Every page supplies the %s part, and the longest one anybody has written is 48 characters. 48 plus 12 is 60, which is why the distribution has a hard wall at exactly the number a search result starts truncating at. The top of the histogram, measured on the live HTML: rendered length pages 60 4 59 54 58 80 57 104 56 88 55 97 Four pages sit precisely on the line. Having a visible brand suffix turns out to be an accidental forcing function: the budget a writer feels is 48, not 60, because the suffix is already there in the template and they are typing into what is left. One page in 991 has no brand in its title title: { absolute: 'Civitas Senior Living Assessment Practice' },
absolute is Next.js's opt out of the parent template, and one employer page uses it. It is the only one in the repository, and the result is a 41-character title with no | CogniPrep on it, where the template would have produced 53 and fitted comfortably. Nineteen characters of unused budget and no brand, which is not a trade anybody would make on purpose. The homepage is the other page without the suffix, and that one is deliberate: it uses the template's default, which is how you give a site root its own title. So: 989 of 991 titles end in the brand, one is the home page, and one is a mistake that no test could see, because it is not a length problem. Now the part that is a mess There are 98 title-length assertions across 50 test files, and they are written five different ways: assertion occurrences toBeLessThanOrEqual(47) 74 toBeLessThanOrEqual(48) 15 toBeLessThan(60) 5 toBeLessThan(48) 2 toBeLessThanOrEqual(60) 2 Four effective ceilings: 47, 48, 59, 60. Two of them are the pre-suffix budget disagreeing with itself by one character, and two are the post-suffix budget disagreeing with itself by one character, and nothing in the repository says which of the four is the rule. Descriptions are better behaved: 135 assertions, all of them toBeLessThan(160), which gives the 159 maximum the live measurement found. The reason for the spread is how the tests were written. Each provider has its own registration test file, many of them produced on separate branches at different times, and each one asserts the limits for its own content. Nobody was copying from a shared constant, because there is no shared constant. There is a prose comment in a type definition that documents 48, and 74 assertions that say 47. The pages on the line are the ones with no test The four titles at exactly 60 characters are per-test pages under three providers. Their providers' registration tests do have title assertions, and here is one of them: it('has a hub whose title and description fit the limits', () => {
const title = /const TITLE = '([^']+)'/.exec(hub)?.[1] ?? '';
expect(title.length).toBeLessThanOrEqual(47);
That reads the hub page's source as text and checks one constant. The per-test pages below that hub are not in the loop, which is exactly why they are the four allowed to reach 48. Coverage by cluster is lopsided in the same way: The 50 files that assert a title length are, with five exceptions, one per assessment provider. There is...

Powered by Readybot.io

SEO Audit: 991 Pages, Zero Duplicate Metadata

Fix GitHub Actions Buildx Cache Reservation Errors

DEV Community

error writing layer blob: failed to reserve cache

"error writing layer blob: failed to reserve cache" in GitHub Actions is the buildx gha cache exporter being refused when it asks the Actions cache service to reserve an entry. The image was usually built and pushed already; what failed is the cache export, and the fix is to stop exporting from the jobs that either may not write or are racing each other for the same key. The export is the last thing a build does, which is why the failure arrives after the image is already pushed. What this error means The build log looks like a success until the last few seconds. The image is built, the push completes, and then the step fails on the export with "ERROR: failed to solve: error writing layer blob: failed to reserve cache". Sometimes one blob is written before it stops, which is what makes it look like a quota problem. The three things people check first come back clean: the cache is nowhere near its limit, the permissions are right, and the same job passed yesterday. It is intermittent on a matrix and consistent on a fork pull request, and those two shapes have different explanations. The block below is quoted from the canonical issue rather than from a run of ours, and the section on reproduction says why. ```Quoted from docker/build-push-action#1571 ERROR: failed to solve: error writing layer blob: failed to reserve cache

Common causes

The workflow has read-only cache access

The most common cause and the most deterministic. Events such as pull_request_target and issue_comment get read-only access by default, so a build under one can read a cache and cannot reserve an entry. It fails identically every run, which is how you tell it from the matrix race.

You raised the limits and added permissions, and it kept failing

The wasted fix, and the reason the canonical issue runs as long as it does. Its reporter confirmed the cache was well inside the limit, added actions: write, tested two major versions of the action and checked the toolchain, and none of it changed the outcome. Quota and permissions are the first two guesses and usually not the answer.

Two matrix legs reserve the same key at the same time

Layer blobs are keyed by digest, ref and repository, and legs that share a base image share those digests. When two exports collide the second reservation is refused. It is intermittent by nature, and adding scope= does not separate them because the scope is not part of the reservation key.

The toolchain predates the cache service v2 cutover

Since April 2025 only the v2 cache API is served, and Buildx, BuildKit, Compose and Engine each have a minimum version that speaks it. A pinned action or a self-hosted image that has not moved will fail on the export even though everything about the workflow is correct.

How to fix it

Import everywhere, export from one place

  1. Remove cache-to from pull request and comment-triggered workflows, and leave cache-from in place.
  2. Populate the cache from the push workflow on your default branch, where write access exists.
  3. Verify by checking that the cache entries appear after a merge rather than after a pull request build.

```.github/workflows/ci.yml

pull_request: read the cache, never write it

  • uses: docker/build-push-action@v7
    with:
    cache-from: type=gha

push to the default branch: write it

  • uses: docker/build-push-action@v7
    with:
    cache-from: type=gha
    cache-to: type=gha,mode=max
    Stop matrix legs from exporting the same layers Export from one leg rather than all of them, or give the legs genuinely different base layers. Exporting from a single leg keeps the benefit, because the layers a matrix shares are exactly the layers the other legs will import next time. - uses: docker/build-push-action@v7
    with:
    cache-from: type=gha
    cache-to: ${{ matrix.node == 22 && 'type=gha,mode=max' || '' }}
    Bring the toolchain up to the v2 minimums Update setup-buildx-action and the build action to current majors, and on a self-...

    Powered by Readybot.io
Fix GitHub Actions Buildx Cache Reservation Errors

WCAG vs APCA: Testing Dark-Mode Text Contrast

DEV Community

Our most used text colour passes WCAG at 6.29 to 1, and APCA says it is only legible at 42px

Yesterday I ran axe-core against all 79 pages of our site and it reported 981 colour contrast failures. Today I want to look at the other side of that number: the colours axe says are fine. The WCAG 2 contrast ratio is a formula from 2008 that divides two relative luminances and adds 0.05 to each to avoid dividing by zero. It is symmetric, which means it does not care whether your text is light on dark or dark on light, and it has a known weakness in the dark half of the range, where that 0.05 flattens real differences. APCA is the candidate replacement being developed for WCAG 3. It is asymmetric, it accounts for polarity, and it returns a lightness contrast value, Lc, from roughly -108 to 106 instead of a ratio. Our site is dark. #171717 background, grey text. That is exactly the region where the two methods are supposed to disagree, so I scored every text colour on the site with both. The instrument Every element on every page that owns a non-empty text node, with its computed colour and the background it actually sits on. Tailwind opacity modifiers mean the computed color is frequently oklab(... / 0.6), which no regex can read, so each colour goes through a 1x1 canvas: ctx.fillStyle = getComputedStyle(el).color; // any CSS colour at all
ctx.fillRect(0, 0, 1, 1);
const [r, g, b, a] = ctx.getImageData(0, 0, 1, 1).data; // sRGB bytes
Then the alpha is composited over the first opaque ancestor background, and the resulting pair is scored twice: once with the WCAG 2 ratio, once with APCAcontrast(sRGBtoY(txt), sRGBtoY(bg)) from apca-w3 0.1.9, copied into the page so nothing is loaded at runtime. The whole site, 79 pages: elements carrying text 8,575 characters of visible text 381,241 distinct text colours 12 distinct backgrounds 7 distinct font sizes 15 distinct weights 4 (400, 500, 600, 700) distinct colour + background + size + weight combinations 52 52 combinations is the entire typographic surface of the site. Every judgement below is one of 52 rows. What WCAG 2 says Four of the 52 fail AA, covering 1,120 elements: text background size elements pages ratio needs #656565 #171717 14px 1,044 15 3.08 4.5 #727272 #171717 14px 68 34 3.73 4.5 #727272 #171717 12px 4 2 3.73 4.5 #585858 #171717 14px 4 2 2.52 4.5 All four are the same mistake: a Tailwind slash opacity modifier on an already muted grey, text-muted-foreground/60 and /70, which produces a colour nobody chose. The worst one lives on the 15 question category pages at about 68 elements each, and those elements average 4.4 characters, so the most numerous failure on the site is also the one carrying the least text. 1,044 elements, roughly 4,000 characters between them. My element level count of 1,120 against axe's 981 node count is the two tools counting different things, not a disagreement: axe skips nodes whose background it cannot resolve and nodes it judges to have no visible text. Same two colours, either way. What APCA says Using the APCA guidance tiers of Lc 75 for body text, Lc 60 from 24px, and Lc 45 for large or bold text, 20 of the 52 combinations fail, covering 5,603 elements. Breaking that against the WCAG result: combinations elements fail both methods 4 1,120 pass WCAG, fail APCA 16 4,483 fail WCAG, pass APCA 0 0 Zero. Every single colour WCAG objects to, APCA also objects to, and APCA then objects to sixteen more. On a dark site the newer model is strictly stricter, and the gap is not marginal. Here is the one that matters, because it is our most used text colour on 76 pages: #999999 on #171717
WCAG 2: 6.29 : 1 pass AA (needs 4.5), pass AAA for large text
APCA: Lc 46.2
6.29 is not a squeak past the line, it is 40 per cent above it. And APCA's own font size lookup table, which is part of the specification rather than my interpretation, says this about Lc 45: Lc min size at weight 400 min size at weight 700 30 108 px 72 px 45 42 px 24 px 60 24 px 16 px 75 18 px 14 px 90 16 px 14 px 100 15 px 13 px We use #999999 at 12px, 14px, 16px and 18px....

Powered by Readybot.io

WCAG vs APCA: Testing Dark-Mode Text Contrast

CodeGraphy: Local-First Code Architecture Visualizer

DEV Community

I built a local-first architecture visualizer and MCP server so AI agents stop hallucinating about my codebase

Working with AI coding assistants on a growing codebase usually hits the same wall: once a project crosses a few dozen files, the LLM starts losing track of how modules actually connect. You end up burning context window tokens just explaining your folder structure, or worse, watching the AI hallucinate imports that don't exist. To fix this in my own workflow, I built CodeGraphy — a local-first software architecture visualizer and Model Context Protocol (MCP) server. What it does Instead of static documentation that goes out of date the moment you commit, CodeGraphy parses your project locally and turns it into an interactive node graph, while exposing that same structural map directly to AI tools via MCP. 100% Local-First: Your code never leaves your machine. No cloud indexing, no API keys required for parsing. Interactive Visual Graph: Built with React Flow, letting you explore file dependencies, imports, and module boundaries visually instead of jumping through endless IDE tabs. Native MCP Server: Connects directly to MCP-compatible clients (like Claude Desktop, Cursor, etc.), allowing your AI assistant to query the actual dependency graph before suggesting architectural changes. Zero-Config CLI: You can spin up a lightweight version right from your terminal. Under the Hood I wanted the tool to be fast to run locally without heavy setup overhead: Backend & AST Parsing: Python + FastAPI Frontend & Graph Rendering: React, React Flow, and Zustand for state management Distribution: Available as a standalone desktop app and a lightweight Python package Try it out If you want to test it on your own repo, you can install the Lite version directly via pip: Bash pip install codegraphy-lite And run it inside your project directory: Bash codegraphy-lite (Insert a screenshot of the MCP tool call in action or the CLI output here) For the full desktop experience, pre-built binaries, and source code, check out the site: 👉 site: click What's next? I'm currently refining multi-language parsing support and optimizing graph layouts for larger monorepos. If you give it a spin, I'd love to hear what breaks, what's missing, or how you're currently giving your AI assistants architectural context. Drop a comment below!

Powered by Readybot.io

CodeGraphy: Local-First Code Architecture Visualizer

Fix GitHub Actions setup-go Version Errors

DEV Community

GitHub Actions setup-go unable to find go version, and what is in the quotes

GitHub Actions setup-go unable to find go version is thrown after the action has searched the published Go download index and found nothing that satisfies the spec it was given for this operating system and this architecture. The spec is quoted in the message, and reading what is inside the quotes settles almost every instance of this failure, because the spec is frequently not the string anybody wrote. The basename dispatch and the fall-through are read from parseGoVersionFile in src/installer.ts. The framed line is quoted from ctrl-research/mmo#3, shortened at the ellipses. What this error means A setup-go step fails before anything is installed, with a message naming a version, a platform and an architecture. Look at the quoted spec first and ask whether it is what you expected. Three shapes turn up. A plausible version number means the spec was right and no published build matches it for that platform and architecture. A version you never wrote means it came from a file rather than from the workflow. The contents of an entire file, comments and all, means the action read a file whose name it does not recognise and used the whole thing as a version string. The platform and architecture at the end of the message are not decoration: the search matches a per-file operating system and architecture, so a version that exists can still be unfindable here. ```Actions log, quoted from ctrl-research/mmo#3; the reporter marked the elisions [error]Unable to find Go version '# Single source of truth for language/tool versions (asdf/mise format). Humans and AI agents should use these versions... golang 1.26.5 nodejs 24.16.0 ...' for platform linux and architecture x64.

Common causes

go-version-file points at a file the action does not parse

The most surprising cause and the easiest to confirm, because the error quotes the file back at you. Only go.mod, go.work and .tool-versions are recognised, by exact basename. A tested-go.mod, a copied manifest under a different name or a version file in a format the action never supported all fall through to the branch that treats the whole file as a version string.

A toolchain directive in go.mod pins a patch that cannot be resolved

The toolchain line is read before the go line, so a repository that bumps toolchains for the go command is also, silently, changing what setup-go tries to install. In our experience this is the cause whenever the quoted version is a precise patch that nobody remembers putting in the workflow.

The version exists but has no build for this platform and architecture

The match is per file, not per release, so an arm64 macOS job or a Windows job can fail on a version a Linux job installs happily. The end of the message names the platform and architecture that found nothing, which is the only place this cause announces itself.

The spec is an exact patch that was never published

A typo, a patch number invented by a bump script, or a release that was pulled. This is the cause the message reads as if it always means, and it is real, but it is the one to check after the three above rather than before them.

How to fix it

Read what is inside the quotation marks before changing anything

  1. If the quotes hold many lines or a comment, the action fell through to its unrecognised-basename branch and the fix is the file name, not the version.
  2. If the quotes hold a patch nobody wrote in the workflow, search go.mod for a toolchain line.
  3. If the quotes hold the version you expected, read the platform and architecture at the end of the message and check that a build exists for that pair.

Give go-version-file a name the parser recognises

Point the input at a real go.mod or go.work, or copy the manifest to that basename first. A file staged under any other name is not rejected, so nothing warns you; the whole file simply becomes the spec.

```.github/workflows/ci.yml (illustrative)
- run: cp tested-go.mod "${RUNNER...

Powered by Readybot.io

Fix GitHub Actions setup-go Version Errors

Host Multiple Apps on One VPS with Docker

DEV Community

Hosting Several Client Apps on One VPS with Docker, Nginx and GitHub Actions

Most small agencies and freelancers end up in the same place: a pile of small client projects. A Next.js marketing site here, a Laravel admin panel there, a Node API for a mobile app, a couple of staging copies. Paying for a separate managed platform for each one adds up fast, and a Kubernetes cluster is far more machinery than a handful of small apps need. This post walks through the setup we use to run several small apps on one VPS: a Docker Compose file per project, Nginx on the host as the reverse proxy, one database container per engine, and GitHub Actions to deploy on every push. Nothing clever. Boring is the point, because boring is easy to debug at 11 pm. The shape of the server Host: Ubuntu LTS with Docker Engine, the Compose plugin, Nginx and Certbot installed directly on the host. Apps: every project lives in /srv/apps/// with its own docker-compose.yml and .env. Ports: each app container binds to 127.0.0.1: only, so nothing is exposed to the internet except Nginx on 80/443. Databases: one MySQL, one PostgreSQL and one MongoDB container on a private Docker network. Each engine holds both the prod and dev databases, with a separate user per database. /srv
├── infra/
│ ├── databases/docker-compose.yml
│ ├── nginx-templates/site.conf
│ └── ports.txt
└── apps/
├── shop/
│ ├── prod/docker-compose.yml
│ └── dev/docker-compose.yml
└── school-crm/
├── prod/docker-compose.yml
└── dev/docker-compose.yml
Why Nginx on the host instead of Traefik or a self-hosted PaaS? Fewer moving parts, less RAM, and a config file you can read top to bottom. On a small VPS that matters. Step 1: a private network and shared databases Create one external network that apps and databases share: docker network create db
Then a single compose file for the database engines: services:
mysql:
image: mysql:8.4
restart: unless-stopped
environment:
MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
volumes:
- mysql-data:/var/lib/mysql
networks: [db]

postgres:
image: postgres:17
restart: unless-stopped
environment:
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
volumes:
- pg-data:/var/lib/postgresql/data
networks: [db]

volumes:
mysql-data:
pg-data:

networks:
db:
external: true
No ports are published, so the databases can't be reached from the internet at all. Apps connect by service name (mysql, postgres), and when you need to open a database from your laptop, an SSH tunnel does the job. Give every project its own user and database per environment, for example shop_prod and shop_dev. A bad migration on dev then can't touch production data. Step 2: one compose file per app Here is a typical Next.js app: services:
web:
image: ghcr.io/your-org/shop-web:${TAG:-latest}
restart: unless-stopped
env_file: .env
ports:
- "127.0.0.1:3101:3000"
networks: [db]

networks:
db:
external: true
Keep a plain ports.txt that maps each project and environment to a port, for example 31xx for prod and 32xx for dev. It sounds trivial, but it is the thing that stops two apps fighting over the same port six months from now. Step 3: an Nginx server block per domain server {
server_name shop.example.com;
client_max_body_size 20m;

location / {
    proxy_pass http://127.0.0.1:3101;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
}

}
Then issue a certificate: sudo certbot --nginx -d shop.example.com
Dev copies get a subdomain such as dev.shop.example.com pointing to the 32xx port, behind basic auth so search engines and random visitors never see half-finished work. We wrapped this in a tiny new-site.sh script that fills the template, runs nginx -t and reloads. Adding a new project is a few commands instead of a small adventur...

Powered by Readybot.io

Host Multiple Apps on One VPS with Docker

CSP Security Audit: 79 Pages, Zero Policies

DEV Community

Zero of our 79 pages send a Content-Security-Policy, and the strict version would need 892 hashes

Our site sends six security headers on every response. Count them yourself: curl -sI https://pub-trivia.app/faq
You get strict-transport-security, x-content-type-options, x-frame-options, referrer-policy, permissions-policy and x-dns-prefetch-control. You do not get a content-security-policy, because there is no CSP anywhere in the 79 pages in our sitemap. I grepped the response headers of all 79: zero hits. I grepped the repository for the string: zero hits. There is exactly one CSP on the whole origin, and we did not write it: curl -sI 'https://pub-trivia.app/_next/image?url=%2Fdemo-1.webp&w=1200&q=75' | grep -i security
content-security-policy: script-src 'none'; frame-src 'none'; sandbox;
That is Next.js hardcoding a policy on its own image optimiser, on the sensible theory that a route which echoes bytes back at you should not be a script host. The framework protects its own route and leaves the other 79 to us. So I went and priced the policy we have not written. The inventory, over all 79 delivered pages thing a CSP cares about count tags with src 1,496 of those, cross-origin 0 of those, with integrity 0 inline tags 1,557 of those, application/ld+json 200 of those, executable 1,357 on* event handler attributes 0 javascript: URLs 0 tags 0 style attributes 468 0 or 0 0 0 with a data: or absolute URL 0 of 77 Most of that table is good news. With no forms, no frames, no plugins, no and no inline handlers, five directives are free and absolute: object-src 'none'; base-uri 'none'; form-action 'none'; frame-src 'none'; frame-ancestors 'self'
That last one is worth a sentence on its own. We send x-frame-options: SAMEORIGIN, which is the 2009 spelling of frame-ancestors and which every modern browser treats as the weaker, less expressive version of a directive we do not send. The 468 style attributes are the first real cost. They hold only 40 distinct values across the whole site, 25,278 bytes in total, and they are Tailwind utilities that could not be static (animation delays, computed widths). A nonce cannot help: nonces apply to elements, and a style attribute is not an element. The options are style-src 'unsafe-inline', or 'unsafe-hashes' plus 40 hashes, which is the directive whose own name tells you how the spec feels about it. The 200 JSON-LD blocks need no hashes, and I checked rather than assumed Our pages carry a lot of structured data, 200 blocks across the 79 pages, all of it . My first count treated them as inline scripts needing hashes, which would have added 122 distinct hashes to the policy for no reason. A data block is not a script. The HTML spec decides the script's type before it gets anywhere near the CSP check, and a block whose type is not a JavaScript type is never prepared for execution, so there is nothing for script-src to block. I wanted to see that rather than cite it, so I made a page with the tightest possible policy, one executable inline script and one JSON-LD block:

window.__ran = 1; {"@context":"https://schema.org","@type":"FAQPage"}

I registered a securitypolicyviolation listener before the document loaded and read it back afterwards: {
"violations": [ { "d": "script-src-elem", "s": "", "l": 4 } ],
"ran": false,
"scripts": 2,
"ldjsonParsed": "FAQPage"
}
One violation, on line 4, which is the executable script. The data block on line 5 produced nothing, stayed in the DOM, and still parses. So script-src 'none' is perfectly compatible with a page full of schema.org markup, which is a relief for anyone whose rich results depend on it. You can see the blocks on any content page of ours, the FAQ has three, by running this in the console: [...document.querySelectorAll('script[type="application/ld+json"]')]
.map(s => JSON.parse(s.textConte...

Powered by Readybot.io

CSP Security Audit: 79 Pages, Zero Policies

Create a Logo with AI for Free: A Beginner’s Guide

DEV Community

How to Create a Logo with AI for Free

I'm not a designer. The first time I needed a logo, I proved it to myself: I opened a design app, stared at a blank canvas for ten minutes, and closed it again. I didn't want to hire a designer for a first version either, because I hadn't worked out what I actually wanted yet. This is a shorter, adapted version of my full guide. Read the full step-by-step guide on TechAI Guide: How to Create a Logo with AI for Free That's where AI logo tools come in. They won't replace a professional designer for a big brand, but for a first logo — a small business, a YouTube channel, a blog, a student club, a side project — they can take you from a rough idea to something you can actually use in under an hour, without spending anything. Start With a Five-Minute Brief Before you open any tool, write down five things: the exact name, spelled exactly as it should appear; one short line about what you do; a single style — modern and clean, friendly and playful, or serious and professional (pick one, not all three); two colours at most; and where the logo will appear. This takes five minutes and saves an hour of aimless clicking later. Without it, every option the AI makes looks fine but feels wrong, and you won't know why. A useful trick: look at three logos you like from businesses nothing like yours, and note one thing you like about each — a clean font, a simple shape, plenty of empty space. That becomes your brief. Choose One or Two Tools, Not Five There is no single best tool, only a best tool for your job right now. Canva is my default pick because you can edit everything afterwards and keep the same colours and fonts across your other posts. Microsoft Designer is the quickest route if you already live in Word and PowerPoint. Ideogram is the one I reach for when the logo has words in it, because it spells text far more reliably than most image generators — though you should still check every letter. Looka and Shopify Hatchful are great for brainstorming dozens of ideas fast; use them to find a direction, then rebuild that direction in a free editor like Canva so you own the editable file. My rule: try two tools, not five. One logo maker and one AI image tool, a shortlist from each, then stop. Trying every tool on the internet turns a one-hour job into a whole weekend. Write a Prompt the AI Can Actually Use "Make me a nice logo" gives you a generic logo. Use a formula instead: business name + what it does + style + colours + where it will be used. For example: "A clean, modern logo for 'TechAI Guide', a blog that explains AI tools in simple words. Simple lightbulb icon, blue and teal, white background, flat design, no extra text." Or: "A friendly logo for 'Sunny Bakes', a small home bakery in Texas. A simple cupcake icon, warm orange and cream, round shape, easy to read on a phone screen." Three rules make a real difference. Say "flat" and "minimal" — detailed images turn into a mess at profile-picture size. Say "no extra text" — AI tools love adding words you never asked for. And name your colours, or you'll get a rainbow and spend your time fixing colours instead of choosing a logo. Generate at least six versions from the same prompt and don't judge the first one; the first is almost never the best. Pick the Simplest One, Then Simplify It More Choosing is the hardest part, because most of us pick the busiest logo — it looks like the most work went into it. On a phone screen, the busiest logo is usually the hardest to read. Run your shortlist through a quick test: can you still read it at thumbnail size? Does it work in black and white? Is there only one idea in it — one icon, one name, one style? Then remove one thing from the winner: an extra line, a second icon, a shadow, a slogan you don't need yet. Show your top two to one honest friend without saying which you prefer, and ask which one they'd remember tomorrow. Trust their answer more than your own — you've been staring at these for an hour and they haven't. Make It Look Professio...

Powered by Readybot.io

Create a Logo with AI for Free: A Beginner’s Guide

Postgres CamelCase Bug Hid Review Prompts for 57 Days

DEV Community

Our review prompt showed to nobody for 57 days, because the driver camelCases every column a raw query returns

CogniPrep asks a paying customer for a Trustpilot review once, and only once, after they have actually used what they bought. The gate is deliberately small: export const REVIEW_PROMPT_MINIMUMS = {
games: 2,
exercises: 1,
interviews: 1,
} as const;
Any one of those clearing its own bar is enough. It is an OR and not a weighted sum, because somebody who has done one full assessment centre exercise has a formed opinion and making them play a game first would be arbitrary. The counts are measured since the purchase, not since signup. So the gate runs one raw aggregate that counts completed games, exercises and interviews twice each: lifetime, and since a timestamp. That query returned the right numbers. The gate read zero for every customer, every time, from 16 September to 12 November. One client option, two kinds of result Our Postgres client sets a column transform: export const DB_TRANSFORM = {
column: { from: postgres.toCamel, to: postgres.fromCamel },
};
Drizzle's query builder is unaffected by that. It reads results positionally and maps them onto the object shape you asked for, so select({ firstPurchaseAt: usersTable.first_purchase_at }) gives you what it says. db.execute is a different path. It hands back postgres.js's own row objects, and the transform has already rewritten every column name on them. A plain AS games_since arrives as gamesSince. The gate was reading row['games_since']. That is undefined, and Number(undefined ?? 0) is 0. Why nothing went wrong loudly Single-word aliases are not affected by a camelCase transform, which is what made this so quiet. The same query selects paid, games, exercises and interviews, and all four of those arrived under the names the code expected. So: hasPaid was correct. We identified customers fine. The lifetime counts were correct. They are what the prompt's own copy and analytics use. Only the three "since purchase" counts and first_purchase_at broke, and those are exactly the four values the decision is made on. Three counts of 0 against a bar of 2, 1 and 1 is three false comparisons ORed together. The function returned needsReviewPrompt: false and did it in good faith. There is no error to log, no row to find, no exception, no Sentry issue. A zero is what a brand new customer legitimately looks like. We had already made this mistake, where it was loud The nurture cron hit the identical thing earlier, selecting AS user_id and reading row.user_id. There it failed immediately and noisily: the undefined user id meant Drizzle substituted DEFAULT on insert, the NOT NULL column rejected it, and a list of undefineds went into an inArray, which failed every campaign in the same run. That one was found and fixed quickly, and the file now carries a long comment explaining the aliases. The difference between the two is not the bug. It is that one of them had a destination that complained. Worth remembering next time you are deciding whether something needs a test: the bug you should fear is not the complicated one, it is the one whose failure mode is a plausible number. The fix is four characters per alias (SELECT count() FROM game_sessions
WHERE user_id = $1
AND completed_at >= $2) AS "gamesSince"
Quoting the camelCase name outright is stable whether or not the transform is configured, which is the property we actually want. There are 15 raw db.execute call sites in this codebase across five files, and a grep for AS [a-z]+[a-z]+ over all of them now returns nothing. The test asserts the SQL, not just the behaviour Behaviour tests would have passed with the bug in place if the fixtures were written in snake_case, because the fixtures would have been wrong in exactly the same way the code was. So the fixture rows are written the way the driver really hands them over: function activityRow(gamesSince: number) {
return {
games: '6',
gamesSince: String(gamesSince),
exercises: '0',
...
};
}
And one test renders the SQL that was actually built and ...

Powered by Readybot.io*

Postgres CamelCase Bug Hid Review Prompts for 57 Days

Wisp: A Fast, Fun Web Framework for Rust

DEV Community

Wisp - A fast, fun web framework for Rust

Hi, I built Wisp, a web framework for Rust. Here is a 90-second video of it: https://www.youtube.com/watch?v=g0LPPzrQux8 The idea: a folder is a URL, and its +page.wisp file is the page. The top of the file is a short block of Rust that loads data and handles forms, and the rest is markup. The templates compile to Rust, so the compiler checks your markup, and the whole app (styles and static files too) ships as one binary. ---
let name = cx.query_or("name", "world".to_string());

Hello, ${name}!

Things I cared about: Forms work with JavaScript off. #[action] handlers validate on the server, and use:enhance updates the page in place when scripts are on. Reactivity lives in the same file: on:click="count++" and {:count}, no separate component. wisp npm add gets a package for browser code, with no Node install. wisp mcp gives coding agents the docs and a checker, so an agent can read how Wisp works and check its own changes. Hosting: one binary on your own server (wisp host keeps it running), static HTML, or a build for Cloudflare, Deno Deploy, Vercel, Netlify, AWS Lambda, Bun and Node. No auth or database layer, on purpose. Wisp gives tools (tables, signed cookies, hooks, uploads) and leaves those choices to you. On AI-written code: the small test app is 477 tokens in Wisp and 1,043 in Nuxt, 2.2x to 3.9x fewer across the stacks I measured (release 1.0.0-pre.3). Method and apps: https://wispweb.dev/docs/tokens/ Status: this is a pre-release (1.0.0-pre.3), MIT licensed, Rust 1.89 or later. The source is at https://code.wispweb.dev/wispdev/wisp for now. It moves to GitHub and crates.io with 1.0. To try it: cargo install --git https://wisp.ar0.eu/ wisp-web
wisp new my-app
cd my-app
wisp dev
I'd love to hear what breaks, what feels wrong, and what you'd need before you used it for a real project.

Powered by Readybot.io

Wisp: A Fast, Fun Web Framework for Rust

How an AI Agent Verifies Crypto Transactions

DEV Community

My AI Agent Moves Real Money. I Never Take Its Word for Anything.

I run an AI agent that operates a crypto wallet on BNB Chain. It mines tokens, claims free mints, and submits transactions on a schedule, including while I sleep. It is also — in the only sense that matters — untrusted. Not because it has misbehaved. Because "the agent said so" is not evidence. Every action it takes has to survive verification against the blockchain itself before anything gets signed. This is a field report on how that works in practice: the checks, the numbers, and the occasions where verification was the only thing between a good story and a bad transaction. It is also an argument for why a competition like the Agent Games, where an agent's work is judged by proofs instead of claims, is the honest format for machines that act in the world. First: every mining proof gets re-proven Two of the agent's standing jobs are mining protocols on BNB Chain, PEARL and AMNT. The pattern is the same for both. A solver program grinds through candidate numbers (nonces) off-chain until it finds one whose proof digest — a hash fingerprint computed from the wallet address and the nonce — falls at or below the contract's current difficulty target. Finding candidates is the easy half, and a solver's log file is full of them. None of those candidates is trusted. Before any batch is submitted, each one is re-verified against the live contract, three ways: Recompute the digest. The digest is recalculated from the wallet and nonce and must match what the solver claimed. A mismatch means the log is wrong, and the candidate is discarded. Check the live target. Targets move. The digest must still be at or below the target the contract reports now, not the target that existed when the solver found it. Check the used-proof registry. The contract records which proofs have already been spent. A proof that appears there is worthless, however good it looks. Only candidates that pass all three are batched. On 13 November 2026, that pipeline submitted 44 verified PEARL proofs and received 3,258.99 PEARL. AMNT runs on a daily cadence: 20 verified proofs a day, 50,000 AMNT a day. Each batch costs roughly 0.00005 BNB in gas — a small amount, but real money, and it is only ever spent on proofs that already passed verification. Second: the transaction itself gets audited Verifying the inputs is not enough, because a correct proof can still ride inside a wrong transaction. So before signing, the wallet builds a preview: a simulation of the exact call, showing precisely what the transaction would do. (A simulation is a dry run of a transaction against current chain state — it shows the outcome without committing anything.) The preview is validated against strict rules: Check What must be true Proof digest Recomputed digest matches the candidate Target Digest ≤ the live target at submission time Unused Proof absent from the contract's used registry Simulation The exact call succeeds in simulation Balance changes Exactly one: the expected reward, arriving at our wallet Allowances / authority No changes at all Gas Worst case under a hard cap, or we stop The balance-change rule does most of the work. If the preview shows anything other than exactly one inbound movement — the expected reward, to our wallet — there is no signature. No exceptions, no "probably fine," no resubmission of a transaction whose outcome is uncertain. A preview that deviates is a full stop, and the deviation gets investigated before anything else moves. Third: marketing lies, contracts don't Free-mint promotions arrive constantly in this ecosystem, and they are written to be believed quickly. Our rule is to read the contract, not the copy. One campaign promised a token bonus for minting a set of shares. Before spending anything, we read the verified contract source. There was no bonus mechanism in it at all — no function, no accounting, nothing that could ever pay it. (A small amount, 0.2 USDT, did arrive later, paid manually off-contract. Which proved the point rather than ref...

Powered by Readybot.io

How an AI Agent Verifies Crypto Transactions

OLED iPad mini 8: Specs, Design, and Market Impact

DEV Community

Apple’s OLED iPad mini 8: Design, Specs, and Impact

Apple’s latest tablet, the OLED iPad mini 8, arrives as the most substantial refresh the mini line has seen in 14 years. While the device retains the familiar 8‑inch footprint, Apple has shaved off a millimeter of thickness, introduced a brighter OLED panel, and equipped the tablet with the A20 Pro SoC—the same silicon that powers the iPhone 18 Pro. In this hands‑on analysis we break down the engineering choices, explore why they matter to consumers and developers, and assess the broader ripple effects across the tablet market. Design Evolution and Build Quality The iPad mini 8 is a study in incremental refinement. At 5.4 mm thick, it is only 0.2 mm thicker than the folded iPhone Duo, yet it is a full millimeter slimmer than its predecessor, the iPad mini 7. The reduction may sound marginal, but it translates into a noticeably lighter device—255 g versus 293 g—making it the lightest iPad Apple has ever shipped. Key physical changes Thickness: 5.4 mm (down 1 mm from mini 7) Weight: 255 g (≈0.56 lb) Materials: Aluminum enclosure with a sealed acoustic cavity Colors: Midnight and Starlight (no bright finishes) The slimmer chassis also allows for a more ergonomic grip, especially for users who hold the tablet for extended reading or sketching sessions. Apple’s decision to forgo the “fun” color palette in favor of classic finishes signals a focus on professional and portable use cases rather than fashion statements. Display Technology: OLED vs. LCD The most visible upgrade is the shift from an LCD to an OLED panel, making the iPad mini 8 the second iPad to receive OLED after the iPad Pro line. The screen now measures 8.5 inches diagonally, a modest increase over the previous 8.3‑inch panel, but the real gain lies in contrast and color fidelity. Contrast Ratio: Near‑infinite, delivering true blacks Peak Brightness: Higher than the LCD predecessor, ensuring readability in bright environments HDR Support: Enhanced HDR rendering thanks to OLED’s wide color gamut Refresh Rate: Fixed at 60 Hz (no ProMotion 120 Hz) While the lack of a 120 Hz refresh may be noticeable to users accustomed to the iPad Pro’s ProMotion, the OLED panel still offers a premium visual experience. The optional nano‑texture glass on higher‑end models reduces glare without sacrificing clarity, a first for the mini line. Performance Core: A20 Pro Chipset Under the hood, the iPad mini 8 runs Apple’s A20 Pro SoC, the same silicon that powers the iPhone 18 Pro. Apple offers three storage configurations, each paired with a slightly different CPU/GPU binning: 🔹 --------- • CPU Cores: ----------- • GPU Cores: ----------- • Notable Benefit: ----------------- 🔹 128 GB • CPU Cores: 5‑core (binned) • GPU Cores: 7‑core • Notable Benefit: Efficient power envelope 🔹 256 GB • CPU Cores: 5‑core (binned) • GPU Cores: 7‑core • Notable Benefit: Same as 128 GB, more storage 🔹 512 GB • CPU Cores: 6‑core (full) • GPU Cores: 7‑core • Notable Benefit: Highest single‑core performance Even the binned 5‑core variant outperforms the A15 found in the iPad mini 7, delivering smoother multitasking and faster app launches. Developers targeting iPadOS 27.3 will benefit from the extra headroom, especially when leveraging the new machine‑learning APIs introduced in the latest beta. For a deeper look at the iPadOS changes, see Apple’s iOS 27.3 & iPadOS 27.3 beta release notes here. Durability and Audio: IP67 and Acoustic Display Apple has taken durability a step further by granting the iPad mini 8 an IP67 rating—first for any iPad. The tablet can survive immersion in up to 1 meter of water for 30 minutes, making it resilient against accidental splashes, rain, or poolside use. While it isn’t marketed as an underwater camera, the rating provides peace of mind for on‑the‑go professionals. Audio architecture also receives a redesign. Traditional speaker grilles are replaced by a sealed “Acoustic Display” system: tiny tweeters sit beneath the glass, while woofers vibrate the display itself to produc...

Powered by Readybot.io

OLED iPad mini 8: Specs, Design, and Market Impact

ChatGPT vs Gemini in 2026: Which AI Is Better?

DEV Community

ChatGPT vs Gemini: Which Is Better in 2026?

I use ChatGPT and Gemini every single day, and people keep asking me the same question: which one is better? After a year of switching between them for writing, research, coding help, and everyday questions, my honest answer is that neither wins everywhere. They are better at different things, and the right choice mostly depends on what you already use and what you do most. This is a shorter, adapted version of my full comparison. Read the full step-by-step guide on TechAI Guide: ChatGPT vs Gemini: Which Is Better in 2026? The Short Version If your life is in Gmail, Google Docs, and Google Drive, Gemini is the natural pick — it is already inside the tools you use, and its paid plan bundles 5 TB of storage. If you do project-based work, study with guided help, or spend a lot of time in Word, Excel, and PowerPoint, ChatGPT fits better. At the popular $20-a-month level they cost almost exactly the same, so price shouldn't decide it. Your workflow should. What They Cost (November 2026, US Prices) Plan ChatGPT Gemini Free $0 $0 Cheapest paid Go — $8/month Google AI Plus — $4.99/month, 400 GB storage Main paid Plus — $20/month Google AI Pro — $19.99/month, 5 TB storage Heavy use Pro — $100, $200 or $500/month Google AI Ultra — $99.99 or $199.99/month Two things worth knowing before you pay. ChatGPT shows ads on its Free and Go plans, but not on Plus or Pro. And eligible US college students can get Google AI Pro free for a year (redeem by 31 December 2026), while ChatGPT's four-free-months student offer closed on 31 October 2026. If you're a US student, that alone may settle it. Prices and model names change fast, so treat this as a mid-November snapshot and check the official pricing pages on the day you subscribe. The Models, Without the Jargon You don't need to memorise model names, but one thing matters: the free plan and the paid plan don't give you the same brain. ChatGPT's family is GPT-6 — the free plan runs GPT-6 Luna, Plus gets the stronger GPT-6.1 Sol, and Pro adds GPT-6 Astra for heavy reasoning, plus Codex for coding on Plus and above. Gemini's family is Gemini 4 — the free plan runs a light Flash model, while Google AI Pro gives you Gemini 4 Argon, the flagship, with a 1-million-token context window (roughly a whole book in one conversation). Google also just launched Gemini 4 Hydrogen (13 November 2026), a fast model that finishes tasks about 2.5 times faster than the old Gemini 3.8 Flash. The practical takeaway: on the free plans, both are good for everyday questions, but neither gives you the flagship. The real difference shows up when you pay — or when you feed in very long documents, where Gemini's 1-million-token window is genuinely hard to beat. How They Compare on Real Work Everyday writing: ChatGPT is slightly better at sounding natural and matching a tone — "make this friendlier" usually lands on the first try. Gemini is close, and writing inside Google Docs is convenient because you never leave the document. Edge: ChatGPT, unless you live in Docs. Research and long documents: This is Gemini's strongest round. Drop in a 200-page report or a pile of PDFs and ask questions across all of it. ChatGPT's context is much smaller, so long documents have to be split up. Both offer good deep research that browses the web, but for "here is everything, now find the answer", I reach for Gemini. Coding help: Both write code, explain errors, and help you debug. ChatGPT has the edge for most people because Codex is built into Plus and its step-by-step explanations are easier to follow when you're learning. Gemini is strong too, especially since Hydrogen is built for fast, multi-step coding work. For learning to code, start with ChatGPT; for speeding through tasks you already understand, try both and keep the one whose answers need less fixing. Images and video: Both generate images good enough for blog graphics and social posts. Gemini's paid plan adds video generation credits (Veo) and image tools inside Google apps, whi...

Powered by Readybot.io

ChatGPT vs Gemini in 2026: Which AI Is Better?

Latchkey vs Blacksmith: GitHub Actions Runner Costs

DEV Community

Latchkey vs Blacksmith for GitHub Actions runners

Latchkey and Blacksmith both replace ubuntu-latest with a one-line runs-on change and both bill per minute, so the choice comes down to three things: the rate, what you need beyond Linux x64, and whether a failed job costs you a re-run. Latchkey is $0.0025 a minute at 2 vCPU against Blacksmith at $0.004, and Blacksmith ships arm64, Windows and macOS runners plus 3,000 free minutes a month, none of which Latchkey has. One month of 10,000 Linux minutes at 2 vCPU on a private repository, at each vendor's published rate with its free allowance applied. Latchkey's plan fee of $5 to $49 sits on top of its bar and is drawn separately. Rates read 20 September 2026. Blacksmith sells managed GitHub Actions runners on its own hardware in Ashburn, Phoenix, Amsterdam and Frankfurt, adopted by installing a GitHub App and changing runs-on to a label such as blacksmith-4vcpu-ubuntu-2404. It publishes $0.004 a minute at 2 vCPU with 8 GB and an 80 GB disk, 3,000 free minutes a month on every plan, a colocated cache that intercepts actions/cache with 25 GB free per repository per week, and sticky disks for Docker layer reuse. Latchkey sells managed runners the same way and at $0.0025 a minute for the same 2 vCPU and 8 GB, on a 100 GB disk, with a self-healing agent that diagnoses and retries transient failures inside the run rather than handing them back red. It is missing things Blacksmith has shipped for a while: no arm64, no Windows, no macOS, and no free monthly allowance outside the trial and the plan tiers. Every cell below was read from the vendor's own public pricing or documentation page on 20 September 2026. Where a vendor does not publish a number, the cell says "not published" instead of carrying a guess. Comparison Blacksmith Latchkey Price per minute, 2 vCPU Linux x64 $0.004 (2 vCPU, 8 GB RAM, 80 GB disk) $0.0025 (2 vCPU, 8 GB RAM, 100 GB disk) Price per minute, 4 vCPU Linux x64 $0.008 (4 vCPU, 16 GB RAM, 80 GB disk) $0.005 (4 vCPU, 16 GB RAM, 100 GB disk) Free tier 3,000 free minutes a month, printed on every runner card 30-day trial, then 2,000 included minutes a month on Developer, 4,000 on Launch, 6,000 on Scale Billing granularity Not published Per minute Runner sizes and OS 2 to 32 vCPU on Linux x64 and arm64; Windows Server 2025 at 2 to 32 vCPU in public beta; macOS M4 at 6 and 12 vCPU 2, 4, 8 and 16 vCPU, Ubuntu 24.04 on x86_64 only. arm64, Windows and macOS are not offered Cache: type, limit, persistence Colocated cache intercepts actions/cache, 25 GB free per repo per week; sticky disks are ext4 volumes, 5 per job, evicted after 7 days idle, $0.50/GB/month Size not published. latchkey-dev/cache-action@v1 replaces actions/cache with a restore step and a save step, keeping path and key (no restore-keys); entries are isolated per organization, versioned by OS, kept 14 days; a failed restore warns rather than failing the job Docker build acceleration useblacksmith/setup-docker-builder@v2 and useblacksmith/build-push-action@v2; layers sit on a sticky disk per cache key, garbage-collected after 8 days unused latchkey-dev/docker-cache-action@v1, layers held in a Latchkey-managed private registry per organization Concurrency limits None imposed, per the runner docs Developer 20, Launch 40, Scale 80 busy runners per workspace; idle warm runners do not count Where jobs run Blacksmith's own regions: Ashburn, Phoenix, Amsterdam and Frankfurt Latchkey's own AWS estate on m6a-class hosts, one job per runner, no inbound access, destroyed after the job Self-healing or retries Not offered Built in: transient failures are diagnosed and retried inside the run Setup change required Install the GitHub App, then change the runs-on label to blacksmith-4vcpu-ubuntu-2404 A runs-on label change. GitHub organization accounts only Where Blacksmith wins, before anything else Blacksmith covers hardware Latchkey does not sell at all. arm64 is generally available at every size from 2 to 32 vCPU, Windows Server 2025 is in public beta across the same ...

Powered by Readybot.io

Latchkey vs Blacksmith: GitHub Actions Runner Costs