BackgrindBlog
Grind coding, written down
Guides and explainers on AI coding agents — installing them, vibe coding, running them in the background, and keeping them out of your way.
-
Explainer What your security team will ask before a coding agent touches the repo
Seven questions a security review actually asks, answered from current documentation rather than a trust page — including the three where the honest answer is "nothing stops that". Where the code goes and why the account matters more than the repo, what a deny rule buys that the model cannot, why a token in your shell is inherited by a dependency’s postinstall script, and the part nobody checks: the default setup writes a plaintext transcript to every developer’s disk and nothing to a central log. Verified against Claude Code 2.1.224, Codex 0.147.0 and MCP revision 2026-07-28.
-
Guide Letting an agent write your tests
The one job everyone hands an agent first, and the one place a wrong answer looks exactly like a right one. We gave Claude Code the same 7-line function twice — once with the implementation, once with only a spec — then broke the code nine ways to see which suite noticed. The implementation-facing suite passed 17 of 17 on a function whose boundary was wrong, hit 100% line, branch and function coverage, and wrote a test literally named '(boundary)' asserting the bug. Mutation scores: 8/9 versus 9/9. Plus the failure modes by name, and why coverage rewards exactly the wrong thing.
-
Guide Debugging with an agent: reproduce first, or you're just editing code
The prompt everyone types is the weakest one available — it names a symptom and asks for a diff, and the cheapest way to satisfy that is to make the symptom stop appearing. So we built a repo with one real off-by-one bug and drove Claude Opus 5 at it twelve times across four prompt styles, scoring every run against a held-out test it never saw. The honest result argues against the scary version: 12 of 12 fixed the root cause, and 10 of 12 executed the failing code before their first edit unprompted. What the arms actually separated on, why a failing test written against a crash message is satisfied by a try/catch, and the three triggers for stopping and reading the code yourself.
-
Guide Migrating a large codebase with an agent
A migration is not one task, it is a thousand nearly identical ones — and that changes how you drive it. The pilot-then-rules-then-batches shape, and the part everyone skips: a codemod beats the agent on the mechanical 80%. Measured on a real 109-file corpus — one line of sed rewrites all 65 declarations and leaves 8 type errors; a 116-line AST codemod rewrites 63, refuses the 2 that need judgment, and finishes clean in 189 ms. Plus the numbers Slack, Google and Airbnb published, worktree parallelism, and the test suite you do not have yet.
-
Guide Running a coding agent inside a container
The thing people reach for the moment they want to stop approving every command — and the one fear it does not remove. A real Dockerfile, a default-deny egress firewall measured before and after, and the four things that break first: a build-arg token that shows up in docker history three times after you deleted the file, a fresh named volume that mounts root-owned, git refusing to commit, and the permission-skip flag refusing to start as root. Plus the hole in every IP allowlist: we reached a blocked host by pinning it to an allowed CDN address. Verified against Docker 29.5.3 and Claude Code 2.1.224.
-
Guide Build your own MCP server: the minimal version, and the parts everyone gets wrong
A complete stdio server in TypeScript, small enough to paste and run, then the parts that decide whether the model ever calls it: the tool description is prompt engineering rather than documentation, and an error should tell the model how to recover instead of just failing. Includes the change that resets the old mental model — tool search is on by default, so your schemas are no longer sitting in the context window waiting to be read.
-
Guide Building an agent on the Claude Agent SDK
Claude Code as a library — and the field almost everyone misreads. We ran the same agent twice: allowedTools is an auto-approve list, not a sandbox, and the first run called Bash despite Bash not being on it. What actually removes a tool, why your canUseTool callback goes silent under bypassPermissions, real turn counts and dollar costs from both runs, and when claude -p is the smaller answer. Verified against SDK 0.3.223.
-
Guide What an AI coding agent actually costs — and how to spend less
The subscription-vs-API crossover is a computable number, not a matter of taste — and the tokens go almost nowhere people assume. We run a 40-turn Opus 5 session at $13.20 uncached and $2.86 warm, work the break-even for Pro, Max 5x and Max 20x, price the same session across four models at a clean 1:2:5:10, and put real numbers on a bloated CLAUDE.md. Plus what /cost, the Console and OpenRouter's activity page each actually report — and the honest counter-argument, which is that a cheap model can take five passes to Opus's one and still come out even.
-
Guide Managing context in a long Claude Code session
The window is the constraint everything else follows from, and file reads are what fill it — about 31% of a representative session, against 1% for your own prompts. What /compact and /clear each do, and the part nobody warns you about: compaction does not bring everything back. Path-scoped rules and nested CLAUDE.md files are lost until a matching file is read again, and invoked skills return capped at 5,000 tokens each. Verified against Claude Code 2.1.220.
-
Guide Gemini CLI: install, configure, and where it fits
Google's terminal agent is the only one of the three with a free tier that works without a card — 1,000 model requests a day on a plain Google sign-in. The three auth paths and what each actually meters, why GEMINI.md silently ignores your AGENTS.md, the nested settings.json shape, MCP and extensions, and a concrete account of where Claude Code and Codex are still ahead. Verified against 0.53.1.
-
Comparison Cloud coding agents compared: Jules, Codex Cloud, and Claude Code on the web
Three agents that run on a machine that is not yours and hand back a pull request. How a task gets in, what each sandbox can reach, where secrets end up, how the result comes back — and the under-documented part: Jules ships a real REST API, Codex Cloud has only a CLI, and Claude Code on the web has no listing endpoint at all.
-
Guide Setting up Claude Code for a team: what to commit, and what stays on your laptop
Precedence is not the same direction for every mechanism: settings.json lets the repo override your home directory, skills let your home directory override the repo, and CLAUDE.md files never override each other at all. What belongs in .claude/, why settings.local.json must be gitignored by the repo and not just by Claude Code, and why a hook in a PR deserves a harder review than the code around it. Verified against Claude Code 2.1.221.
-
Explainer Skills vs plugins vs MCP vs subagents in Claude Code: how to choose
Six extension mechanisms, and only three of them are different kinds of thing. What each one is, where it lives, when the model reaches for it, and the honest edge cases where two genuinely overlap — plus the two changes that broke everyone's mental model: custom commands are now skills, and MCP tool schemas are no longer always in context. Verified against Claude Code 2.1.221.
-
Guide How to install Claude Code skills — both ecosystems, end to end
Everyone writes "put a SKILL.md in ~/.claude/skills". The real picture is two ecosystems with two installers that cannot see each other: marketplace plugins via claude plugin install, plain-git skills via npx skills. Where the files actually land, how to audit both, and the commit-pinning trap that works on four sources and fails everywhere else.
-
Explainer The security model of agent skills: what you are actually installing
A skill is not data — it is instructions that steer your agent inside your repository, with your credentials. One realistic attack chain traced end to end, why the permission system rather than the skill file is the trust boundary, why commit-pinning fails outright for most repos through the Skills CLI, and how prompt injection composes with a permissive skill. Verified against Claude Code 2.1.221.
-
Guide Codex CLI sandbox modes: read-only, workspace-write, and when each is right
Codex is the one terminal agent whose sandbox the kernel enforces — Apple Seatbelt on macOS, bubblewrap plus seccomp on Linux (Landlock is now the legacy path). What each mode really permits, why sandbox mode and approval policy are two separate dials, why --full-auto is gone, and the recipes for review, local work and CI. Verified against 0.146.0.
-
Guide Codex CLI notifications: how the notify hook actually works
The notify hook has exactly one event, hands you the payload as an argv argument rather than on stdin, and can never block a tool call. The verified payload shape, a runnable script, per-run vs global wiring, and when to reach for lifecycle hooks instead.
-
Industry GPT-5.6 Sol, Terra and Luna: what each tier costs, and which one to point at your repo
OpenAI's GPT-5.6 family split three ways. What Sol, Terra and Luna actually cost once you count the 272K cliff and the new 1.25x cache write — and which one belongs in your Codex sessions.
-
Explainer Kimi K3 open weights: the self-hosting reality check
Moonshot released Kimi K3's weights on July 27, 2026. What that actually gets you at 2.8 trillion parameters — the real download size, the hardware floor, the bespoke license, and how to choose between self-hosting, the official API, and an aggregator.
-
Guide Per-subagent model control in Claude Code: let the cheap model grind, the expensive one judge
A model: key in a subagent's YAML frontmatter picks the model for that leg of the work. Haiku workers plus one Opus judge take an eight-way fan-out from $3.00 to $0.80 — and unlike /model mid-session, it leaves the parent's prompt cache intact.
-
Guide How to install Kimi Code, Moonshot's coding-agent CLI
Install commands for macOS, Windows and npm, the OAuth vs API-key sign-in, the real Node floor, the telemetry-on-by-default caveat, and what a K3 session costs on a membership vs the API.
-
Industry Claude Opus 5: what actually changed, and who should switch
Claude Opus 5 landed July 24 at $5/$25 per million tokens — the same as Opus 4.8 and exactly half of Fable 5. We break down the pricing table, the five-level effort ladder the press got wrong, Fast mode's 2.5x-for-2x tradeoff, and the ARC-verified benchmark jump. Plus the three defaults that flipped and will quietly change your Claude Code sessions.
-
Comparison Claude Opus 5 vs Claude Fable 5: the price/capability crossover, in numbers
Opus 5 costs exactly half of Fable 5 on every line of the meter and, on Anthropic's own launch benchmarks, gives up almost nothing on coding. We run the per-session math at a realistic 20:1 input:output ratio, unpack the Pro-vs-Max subscription split that now bills Fable 5 as credits, and land on a routing rule: default to Opus 5, escalate deliberately.
-
Guide Claude Code effort levels: a practical guide to /effort (and Opus 5)
Effort isn't a thinking dial — it changes every token Claude emits, including tool calls and preamble. This guide covers what each of the five levels does, a task-to-effort routing table, how effort interacts with per-token cost, prompt caching and subscription usage windows, and Anthropic's own heuristic for raising effort versus reaching for a bigger model. Plus what's genuinely new on Opus 5, and why ultrathink doesn't do what people think it does.
-
Guide Switching models mid-session: why cheap-by-default beats picking one model for everything
Cheap by default, escalate on the hard parts is the right instinct — but every model switch in Claude Code throws away the prompt cache, and Anthropic's own docs show a case where downshifting to Haiku costs 2x more than staying on Opus. We work the arithmetic on a 200k-token session, cover how /model, Cursor's picker and Codex differ, and explain why subagents are the cache-safe way to escalate.
-
Explainer Agentic coding benchmarks in 2026, decoded: what each one actually measures
SWE-bench Verified is effectively retired, Terminal-Bench measures the harness as much as the model, and only Frontier-Bench v0.1 and ARC-AGI-3 still have headroom. We decode what each benchmark actually measures, why July 2026 scores jumped (three causes, only one of them capability), and where the contamination and self-reporting caveats bite. It ends with the five-task, blind-scored protocol that beats every leaderboard for your own codebase.
-
Explainer Claude Code usage limits, explained — and what to do when you hit one
Two meters run at once: a 5-hour rolling window and a weekly cap, and agent sessions burn both faster than chat ever did. How the system actually behaves in 2026, why input tokens are the culprit, and the four-move playbook for "usage limit reached."
-
Guide Claude Code slash commands: the ones that actually matter
/help lists them all; this is the shortlist that deserves muscle memory. Session hygiene with /compact and /resume, model routing with /model, /background for detached work — and the underrated bit: your own commands as Markdown files the whole team shares.
-
Guide Five Claude Code hooks worth copying (with the settings.json to paste)
The docs explain what hooks are; here are five working recipes to steal — the "it needs you" ping, a done chime, Discord webhooks, phone alerts via ntfy.sh, and a PreToolUse gate that blocks dangerous commands before they run.
-
Guide Claude Code on Windows: native vs WSL, and the gotchas nobody mentions
Yes, it runs natively — the real question is where the agent should live. One rule decides it, and three gotchas (PATH, line endings, Defender vs node_modules) cause most of the misery. The Windows deep end of our install guide.
-
Guide Running cursor-agent in the background (without losing its questions)
The Cursor CLI is brilliant at fire-and-forget (print mode) and silent at running-but-reachable: no hooks, no /background. What each mode gives you, where tmux still leaves you blind, and how to assemble the missing notification layer.
-
Comparison Claude Fable 5 vs Kimi K3: the frontier tax meets a 2.8T open-weight challenger
Anthropic’s frontier is back and pay-per-token; Moonshot’s 2.8-trillion-parameter K3 costs a third as much and promises open weights. Benchmarks, pricing, availability in coding agents — and why the right answer is a council seat, not a marriage.
-
Comparison China's coding models, July 2026: who's actually good at what
Kimi K3 and K2.6, GLM-5.2, DeepSeek V4, Qwen3 Coder — the July wave put Chinese labs within a few points of the US frontier at a fraction of the price. Who owns which axis, the honest caveats, and the ten-minute way to test them on your own repo.
-
Explainer Fable 5 went pay-per-token on July 20. Here’s what it actually costs to code with
The included-access promo ended July 19; now it’s $10/$50 per million tokens on credits. Why agent sessions are input machines, what a real Claude Code hour costs on Fable 5, and a routing policy that saves the frontier for where it earns its price.
-
Guide How to run Kimi K3 as a coding agent, today
Moonshot’s 2.8T flagship speaks the OpenAI dialect, which means it’s ten minutes from your terminal: a Moonshot or OpenRouter key, OpenCode as the host, and a five-task gauntlet to see if it beats your current model on your code — not on a leaderboard.
-
Guide GPT vs Claude vs Gemini: the only AI model comparison that matters runs on your codebase
Public benchmarks don’t transfer — contamination, task mismatch, and no benchmark knows your conventions. A practical protocol: five real questions from your git history, identical context, blind scoring — and a council that automates the loop with read-only CLI seats and an anonymizing chairman.
-
Comparison AI code review in 2026: every tool shares one gap — and a second reviewer closes it
An honest survey of the 2026 landscape — Copilot code review, CodeRabbit, Qodo Merge, Claude Code /review, Cursor Bugbot — and the structural gap they share: one model, one perspective. The multi-model second-reviewer pattern for high-risk diffs, a risk-to-depth decision table, and the real cost math.
-
Guide The best thing to do with your OpenRouter key: convene a council
One key, one bill, every frontier model — the exact shape a model council needs. Ask GPT, Gemini, and DeepSeek the same hard coding question and let a chairman judge one verdict: the manual curl version, the automated council with a searchable any-model picker, and the cost math (cents).
-
Explainer How to catch AI hallucinations: ask a model that wasn’t trained by the same lab
Hallucinations survive because you asked one model — re-rolling it resamples the same blind spot. Cross-model checking breaks correlated errors: independent convergence earns confidence, a split is the signal to slow down. The protocol, a worked example, and the honest limits of consensus.
-
Guide The multi-agent coding setup for 2026: several agents, one machine, one view
The practical stack for running Claude Code, Codex, and cursor-agent as one team: one agent per folder or worktree, a mission-control board, coordination for same-folder agents, pre-approval policies so ten agents don’t mean ten interruptions, and a council for the hard calls.
-
Guide Claude Code wrote it — how do you know it's right? Getting a real second opinion
Same-model review inherits the same blind spots. How to cross-check a Claude Code plan with independently trained models — the manual paste-into-three-chats way, the read-only CLI way, and a one-hotkey council with a chairman verdict — plus when a second opinion isn’t worth it.
-
Guide How to ask multiple AI models one question — and trust what comes back
When one answer is not trustworthy — architecture calls, gnarly bugs, security — ask Claude, GPT, and Gemini the same question and judge the spread. The council pattern with browser tabs, a worked example with a split verdict, and how to automate it on the CLI subscriptions you already pay for.
-
Explainer LLM as judge: what model consensus — and disagreement — actually tells you
Disagreement between AI models is signal, not noise. Why rubric-based judging beats a majority vote, the documented judge biases (verbosity, self-preference, rubric gaming), and an AGREEMENT/CONFIDENCE contract that only interrupts you when models actually split.
-
Comparison Which AI coding agent should I use? An honest decision guide
There is no single best AI coding agent — it depends on four axes. An honest guide to Claude Code, OpenAI Codex CLI, Cursor, and OpenCode, with a 30-second quiz that picks one for you.
-
Explainer Claude Code subagents explained: isolated context, fan-out, worktrees
A Claude Code subagent is a focused worker the main session spawns with its own fresh, isolated context window. How to define and manage them, the built-ins, fanning out work in parallel, worktree isolation, and why a fan-out means a flood of "done" events.
-
Guide Claude Code MCP servers: what they are and how to set them up
MCP servers let Claude Code talk to external tools and data — GitHub, Linear, Postgres, Sentry, Playwright — over a standard protocol. The scopes, the config file, the real claude mcp add command, and the trust caveat.
-
Comparison CLAUDE.md vs AGENTS.md: which project context file should you use?
AGENTS.md is the cross-tool context file read by many agent tools; CLAUDE.md is the Claude Code native file that can point at it. What to put in each, how to nest them, and why one short file should drive whatever CLI you run.
-
Guide How to install OpenCode (macOS & Windows)
Install OpenCode on macOS or Windows, wire up a model provider, and run your first prompt — plus the honest catch with using a Claude subscription, and how to float it in an overlay.
-
Guide Run OpenCode in the background, as an always-on-top overlay
Run OpenCode in the background and float it as an always-on-top overlay over your editor, browser, or a borderless-fullscreen game — with ambient notifications instead of babysitting.
-
Comparison Claude Code Agent View vs an overlay for parallel sessions
Claude Code Agent View is a terminal dashboard for parallel background sessions. An honest look at what it nails, where it stops, and how a cross-agent overlay differs.
-
Guide Git worktrees + Claude Code: run parallel agents without conflicts
Use git worktrees with Claude Code to run multiple agents in parallel without edits colliding — the stable git worktree add workflow, the 3-to-5 sweet spot, and why the real bottleneck becomes watching them.
-
Comparison OpenCode vs Claude Code: which terminal agent should you run?
OpenCode runs across 75+ model providers under MIT; Claude Code is faster but Anthropic-only. A straight comparison — providers, architecture, cost, speed, and the early-2026 OAuth block that changed the math.
-
Comparison A Claude Code remote control alternative, and where native stops short
Anthropic shipped native Remote Control in Feb 2026 — free, but Claude-only and tied to an open terminal. An honest look at where it stops, and a Live-mode alternative that spans Claude Code, Codex, Cursor, and Grindy.
-
Guide Claude Code notification when done: every method, ranked
Get a Claude Code notification when it finishes: the one-line terminal bell, a Stop-hook desktop alert, a phone push, and ambient overlay toasts that reach you over fullscreen. A DIY-first ladder, least to most reachable.
-
Explainer What is OpenCode? The most-starred open-source coding agent
OpenCode is the open-source, terminal-native AI coding agent with a client-server design and 75+ model providers. What it is, who makes it, the OAuth block, and how the hosted Grindy agent builds on it.
-
Guide Coding with ADHD: making AI agents work for your brain
AI coding agents line up with ADHD brains in real ways — lowering task-initiation, holding context you'd otherwise lose, and turning dead waiting time into progress. An honest look at what helps, what backfires, and a setup that works with your attention.
-
Comparison The best AI coding agent in 2026: an honest field guide
There's no single best AI coding agent — there's the best one for how you work. A balanced field guide to Claude Code, Cursor, Codex CLI, Gemini CLI, Aider, and Copilot, and the four axes that actually decide the choice.
-
Comparison Claude Code alternatives: the real options, compared
Looking for a Claude Code alternative? An honest rundown of the real options — Cursor, Codex CLI, Gemini CLI, Aider, and GitHub Copilot — what each does differently, and why switching is cheaper than you think.
-
Comparison Cursor vs Codex CLI: editor agent vs terminal agent
Cursor builds the agent into your editor; Codex CLI builds it into your terminal. How they differ on autonomy, openness, and pricing models — and why running both beats choosing.
-
Guide How to control your AI coding agent from your phone
Kick off a task, walk away, and still drive the agent from your phone — watch the terminal live, type follow-ups, and approve prompts from anywhere. What remote control actually needs, the DIY options, and how to do it without exposing your machine.
-
Explainer Is there a GUI for Claude Code?
Claude Code is a terminal app — but you don’t have to live in a raw terminal. The real options for a Claude Code GUI, from a nicer terminal to the IDE extensions to a purpose-built overlay with a file tree, diffs, and click-to-approve.
-
Explainer What is an AI coding agent overlay?
An always-on-top window that runs your agent over whatever else you’re doing. What an overlay actually is, how it differs from a terminal or IDE, and why the ambient shape is the right fit for agents that run unattended.
-
Guide Automating Claude Code safely: pre-approval policies that actually work
Approving every tool call defeats the point of an agent; approving everything defeats the point of a review. The middle is a policy: granular rules on repo, tool and command that the PreToolUse hook evaluates before the agent is allowed to act, with deny beating allow and an audit trail you can read afterwards.
-
Industry GTA 6 lands November 19, 2026 — here’s how to ship code the whole wait
GTA 6 is locked for November 19, 2026, with pre-orders opening June 25. AI is the headline on both sides of the screen — and here’s how to run Claude Code in an overlay while GTA 6 (and everything before it) is on.
-
Guide How to install and use cursor-agent (macOS, Windows & Linux)
Cursor’s editor gets the attention, but it also ships a standalone terminal agent. Here’s how to install cursor-agent on macOS, Windows, and Linux, sign in, keep it updated, run it in a repo, and how it stacks up against Claude Code.
-
Guide How to set up OpenAI’s Codex CLI
Codex is OpenAI’s open-source terminal coding agent. Here’s the clean path from npm install to your first run, plus how to use its notify hook so an agent can tell you when it’s done.
-
Guide Your first vibe coding project, start to ship
The hardest part of your first vibe coding project isn’t the agent — it’s picking something small enough to finish. Here’s the whole path: scope it tiny, git init, describe the goal, iterate in small steps, keep your .env out of reach, and ship.
-
Explainer What Claude Code hooks are, and why they matter
A hook is just a shell command that gets a JSON payload on stdin when the agent hits a lifecycle event. That simple model is how you gate dangerous commands and get told the moment the agent needs you — no babysitting.
-
Explainer Build vs Plan mode: when to let your AI agent think before it edits
Plan mode reads and outlines without editing; Build mode makes the changes. Here’s the plan-then-build workflow, and how Backgrind exposes a per-task toggle.
-
Comparison Claude Code vs Cursor: terminal-first vs editor-integrated agentic coding
Claude Code lives in your terminal; Cursor lives in your editor (and now ships cursor-agent for the CLI too). Here’s where each one wins, how their autonomy and pricing models differ, and why picking one isn’t really the decision it looks like.
-
Comparison Claude Code vs Codex CLI: which terminal agent fits your workflow?
Claude Code and Codex CLI are the two big terminal coding agents. They share a shape — point them at a repo, describe a task, watch them edit and run commands — but differ on autonomy, config, and ecosystem. Here’s an honest side-by-side.
-
Guide How to run several AI coding agents in parallel without losing track
One agent per repo or feature parallelizes the boring 80%. The trap is juggling windows and missing the one agent that’s blocked. Here’s the pattern that scales.
-
Guide Voice-controlling your AI coding agent: when talking beats typing
Agentic coding is about describing intent, not typing syntax — which is exactly what your mouth is good at. Here’s a practical dictation workflow, why on-device speech-to-text matters for privacy, and when voice actually beats the keyboard.
-
Guide How to install Claude Code (macOS & Windows)
Prerequisites, the npm install command, signing in, your first run, and the Windows/WSL gotchas — plus how to keep the agent from burying itself in a terminal.
-
Explainer What is vibe coding, really?
Where the term came from, what it actually means, why it is not just for beginners, where it works and where it bites, and how to do it well.
-
Guide Stop babysitting your AI agent: how to know when Claude Code needs you
The DIY ways to get notified when Claude Code finishes or needs input — terminal bell, Stop/Notification hooks, terminal-notifier, Pushover — ranked by real tradeoffs.
-
Explainer Why you want an always-on-top terminal for AI coding agents
An always-on-top terminal is the right shape for AI agents — the macOS/Windows ways to pin one, their limits, and what an agent-aware overlay adds.
-
Guide How to run Claude Code in the background (and still catch when it needs you)
Detached runs lose the approval prompt. The difference between truly headless and "running but still notified" — and the workflow most devs actually want.
-
Industry Anthropic's Fable 5 suspension: what actually happened
Anthropic launched Claude Fable 5, then suspended it days later under a U.S. export-control directive over a 'jailbreak' that was a coding task. The verified timeline.
-
Guide How to run Claude Code while playing a game
Borderless fullscreen, an always-on-top terminal overlay, and notifications that only fire when the agent needs you — without anti-cheat risk.
-
Explainer Will a coding overlay get me banned?
How anti-cheat actually treats overlays: render injection vs a plain always-on-top window, what gets flagged, and where a terminal overlay sits.
-
Explainer Borderless vs exclusive fullscreen: why overlays only work in one of them
What each display mode actually does, the performance myth on modern Windows, and the compositor detail that decides what can draw over your game.
No posts in this category yet.