DEV Community: Peak

The Google Business Profile Audit: A Room-by-Room Walkthrough

Peak — Mon, 21 Sep 2026 03:10:00 +0000

The Google Business Profile Audit: A Room-by-Room Walkthrough

An agency sells you a "GBP audit" as a mysterious deliverable. Here's the open secret: it's a checklist. Anyone can run it — you, this afternoon, in the Google Business Profile dashboard, for free. What you're buying from the agency isn't secret knowledge; it's an hour of someone else's attention and the discipline to look at every room instead of the two you already know are messy.

This post is that walkthrough. Five rooms — identity, completeness, reputation, media, technical health — with a checkpoint list for each: what to check, what "pass" looks like, and the fix when it fails. Print it, open your dashboard in another tab, and mark as you go. (If you want the ranked "which lever matters most" thinking, that's the companion piece on GBP optimization; this one is the systematic inspection.)

The short version: A Google Business Profile audit is a systematic check of five areas: identity (name, categories, address, phone, hours — correct and consistent), completeness (services, products, description, attributes filled in), reputation (review flow, ratings, replies, Q&A), media (fresh real photos, videos, recent posts), and technical health (your ownership, no duplicates, no warnings, insights readable). Each finding gets a concrete fix in the dashboard. Done properly it takes about an hour and needs no paid tools.

Room 1: Identity — Who Google Thinks You Are

The foundation room. Everything else underperforms if identity is wrong.

#	Checkpoint	Pass looks like	Fix if it fails
1	Business name	Your real name only — no "Bangkok", no service words added	Edit to bare name; move keywords to services/posts
2	Primary category	The one thing you most want to be found for	Change it; expect ranking shifts for 2–4 weeks after
3	Secondary categories	2–4 accurate, no hopeful stuffing	Remove irrelevant ones
4	Address	Exactly matches your site and other listings	Correct it; then fix the other listings to match
5	Phone	One primary number, clickable, in use	Update; check old numbers still listed in directories
6	Hours	Current, plus special hours for upcoming Thai holidays	Set special hours for the next 60 days
7	Service area (if no storefront)	Real neighborhoods you serve — no fake pins	Trim to reality

The category checkpoint deserves a second look even if you think you pass: Google renames and reorganizes its category taxonomy several times a year, and a category that was right in 2024 may silently no longer exist in the form you picked.

Room 2: Completeness — Every Field Filled or Deliberately Empty

Google treats profile completeness as an effort signal, and customers treat empty fields as red flags. Walk every tab:

Services / products: listed with search-shaped names and one-line descriptions. "Same-day crowns" beats "Dental". Bilingual service names where genuinely bilingual.
Business description: 750 characters, offering in the first 250, no keyword stuffing, no URLs.
Attributes: every relevant toggle set — outdoor seating, halal, English-speaking staff, free Wi-Fi. Attributes feed the qualifier chips customers filter with.
Booking/appointment links: present if you take bookings; a dead link is worse than none, so click it.
Website link: correct URL, correct protocol, loads on mobile in under a few seconds.
Opening date / social profiles: filled where the dashboard offers them.

{
  "completeness_targets": {
    "services": "all real offerings, search-shaped names",
    "description": "750 chars, offering first",
    "attributes": "every relevant toggle set",
    "link": "loads on mobile, tracked separately from direct traffic"
  }
}

A field left empty deliberately (you don't do deliveries — don't claim delivery) is a pass. An empty field you never got around to is a finding.

Room 3: Reputation — What Customers See and Say

Review count and rating trend: not just the number — the last 90 days. A 4.8 built on reviews that stopped six months ago reads differently than a 4.5 flowing weekly.
Review keywords: do reviews mention what you want to be found for? If nobody mentions your actual service, invite the mention naturally at the counter ("tell Google what you came for").
Reply coverage: every review answered, in the reviewer's language, including the 3-star shrugs. Unanswered negative reviews are the loudest thing on your profile.
Fake/hostile reviews: flagged (report in the dashboard), never argued with in public beyond one calm factual reply.
Q&A: your top-5 real customer questions seeded and answered — both languages if your customers mix. Check for stranger-answered questions with wrong info and correct them with your own answer plus an upvote.

Room 4: Media — The Room Everyone Photographs Badly

Photo count and freshness: something new in the last 30 days. Real phone photos; exteriors at night matter on dark Bangkok sois.
Cover photo: deliberately set — the one photo that represents you in search, not whatever Google auto-picked.
Category coverage: exterior, interior, product, team. A profile of only food photos tells Google and customers nothing about the place.
Video: one short clip (even 15 seconds) if you have it.
Posts (Updates tab): at least one post from the last 30 days, specific and true. The tab is also a trust signal: a ghost-town Updates tab reads as a closed business.
Logo and cover: uploaded, current, not pixelated.

Room 5: Technical Health — The Room Behind the Walls

The checks most owners never open, where the expensive problems live:

Ownership: you hold owner-level access with your own email — not an agency's, not a former employee's. Managers come and go; the owner account is the deed to the house.
Duplicate profiles: search your business name and address on Maps. One listing only. If you find a second — old address, agency-created, employee-created — request merge/removal through support. (Full method in the NAP consistency piece; this is the checkpoint form of it.)
Account warnings: the dashboard's policy section shows violations and suspension risk. A suspended profile explains most "sudden invisibility" mysteries.
Verification status: verified, and re-verified after any address change.
Insights readable: Performance tab shows calls, direction requests, website clicks, and the search phrases that found you. No data for weeks = something upstream is broken.

Scoring the Walkthrough

Don't aim for perfection; aim for findings with fixes attached. A useful output format:

IDENTITY       6/7   — primary category wrong (fix: Restaurant → Coffee shop)
COMPLETENESS   4/6   — attributes empty; description missing first-250 offering
REPUTATION     3/5   — 0 replies to last 6 reviews; Q&A unseeded
MEDIA          2/6   — no new photo in 5 months; cover auto-picked
TECHNICAL      5/5   — clean ownership, no duplicates
TOTAL         20/29  — biggest lever: media room, this week

That "biggest lever" line is the actual deliverable an agency would sell you: the one or two rooms where an hour of work moves the most. Re-run the walkthrough monthly — it takes 20 minutes once the first pass is done — and the scores become your progress log.

Room	First-pass time	Typical finding	Payoff speed
Identity	15 min	Wrong/stale category	Weeks
Completeness	15 min	Empty attributes, weak description	Weeks–months
Reputation	15 min	Unanswered reviews, unseeded Q&A	Months, compounding
Media	10 min	Stale photos, ghost Updates tab	Weeks
Technical	10 min	Duplicate profile, agency-owned account	Immediate once fixed

Frequently Asked Questions

How often should I audit my profile?

A full five-room walkthrough every quarter, with the technical room (duplicates, warnings, ownership) checked monthly — those fail silently and expensively. After any big change — move, rebrand, category edit, new branch — re-run the identity and technical rooms the same week.

Can I pay someone to do this audit?

Yes, and now you know exactly what you'd be buying: this checklist, run attentively, with findings written up. It's a legitimate service — but run this free version first. Either you'll fix everything yourself, or you'll hand the agency a precise scope instead of a blank check.

What's the most common audit finding in Bangkok businesses?

Three, tied: stale primary categories (taxonomy drift), unanswered reviews in the "other" language (Thai owners skipping English reviews and vice versa), and duplicate profiles left over from a previous agency or an enthusiastic employee. All three are fixable in a day.

Will fixing audit findings change my ranking?

Individually, each fix is modest — this is plumbing, not fireworks. Collectively, a profile that passes all five rooms removes the quiet caps that were holding back your reviews, categories, and content work. Judge it the honest way: grid-scan before the fixes, rescan the same grid a month after, compare shapes.

An audit isn't a judgment — it's a map. Twenty-nine checkpoints, an hour, and you'll know exactly which room of your shop Google has never been allowed to see properly.

Start with the "before" picture: run a free Google Maps grid scan at gbppeak.com/free-maps — no signup — then audit, fix, and rescan the same grid in a month to see what moved.

Stop Retyping Everything: A Slash-Command Console for Your Local LLM Stack

Peak — Fri, 18 Sep 2026 04:04:59 +0000

You've built the perfect local LLM session ritual. It goes: reset the context with a rolling summary, re-inject the profile, set num_ctx, pull in the right prompt file, then finally ask your question. Fifteen minutes of setup knowledge that makes the output excellent — and you retype or re-paste some version of it every single session, because it lives in your head and your clipboard history.

Meanwhile, the cloud CLI tools solved this exact problem years ago with slash commands: /compact to summarize the thread, /model to swap engines, /deploy to fire a saved multi-step playbook. One terse line controls the tool while your normal words control the task. It's a good pattern — and unlike the models themselves, the pattern is trivially copyable. Nothing about it requires a vendor. A local stack is already a pile of files, scripts, and a model server; a command console over that pile is an afternoon of bash.

Here's the build: a tiny lm command, three species of command behind it, and the habit that turns your best session rituals into one-line operations — for you and for your automations.

The short version: A slash-command console for a local LLM stack is a small shell CLI (e.g. lm) that dispatches typed commands to three species: prompt-commands (markdown files injected into the session), tool-commands (scripts that change state — context resets, model switches), and connector-commands (MCP-style tool calls). Local equivalents of the famous ones: /compact becomes a rolling-summary script, /model flips a MODEL_TAG variable behind one local API door, and /skill loads a saved playbook file. Because the console is just a script surface, n8n workflows can call the same commands — one control layer for humans and automations.

Three Species of Command

Every slash command you've envied in a cloud CLI decomposes into exactly three species. Sorting them this way is what makes the local build clean:

Species	What it does	Lives as	Example
Prompt-command	Injects a saved prompt/instruction set	`.md` file in `commands/`	`/skill review-pr` loads the review playbook
Tool-command	Changes state outside the conversation	Bash/Python script	`/compact` summarizes + resets context
Connector-command	Calls an external tool or API	MCP server / HTTP call	`/issue list` queries the tracker

The distinction matters because the species fail differently. A prompt-command that's wrong just produces a bad draft (edit the file, retry — free). A tool-command that's wrong changes something (deleted context, switched model mid-task) — those get a confirmation step. Design the console with that asymmetry in mind: prompt-commands are safe to fire freely; tool-commands ask before they act.

The Translator: Cloud Command → Local Equivalent

Before building, notice how directly the famous commands map:

Cloud CLI	Job	Your local version
`/compact`	Summarize thread, free context	Script: model summarizes session → save → start fresh session with summary
`/clear`	Hard reset	`rm session.md` (or new session file)
`/model`	Switch engine	Flip `MODEL_TAG` in your env — one door, new engine
`/context`	Show window usage	Token-count script over the session file
`/skill deploy`	Saved multi-step playbook	`commands/deploy.md` prompt file
`/help`	List commands	`ls commands/` — the folder IS the menu

The cloud tools bundled decades of operator ergonomics into a CLI. The ideas are portable; the vendor isn't required.

Build the Launcher

One small dispatcher is the whole interface. Bash keeps it inspectable:

#!/usr/bin/env bash
# lm — slash-command console for the local stack
CMD="$1"; shift || true
CMDIR="${LM_COMMANDS:-$HOME/.lm/commands}"
SESS="${LM_SESSION:-$HOME/.lm/session.md}"
MODEL_TAG="${MODEL_TAG:-llama3.2}"
API="http://localhost:11434/v1"

case "$CMD" in
  /help|help)  ls "$CMDIR" | sed 's/\.md$//;s/^/  \//' ;;
  /clear)      : > "$SESS"; echo "session reset" ;;
  /context)    wc -w "$SESS" | awk '{printf "~%d tokens on the board\n", $1*1.3}' ;;
  /model)      export MODEL_TAG="$1"; echo "engine: $MODEL_TAG" ;;
  /compact)    exec bash ~/.lm/scripts/compact.sh ;;
  /*)          F="$CMDIR/${CMD#/}.md"
               [ -f "$F" ] && cat "$F" >> "$SESS" && echo "loaded ${CMD#/}" \
                            || echo "no such command — /help" ;;
  *)           echo "$*" >> "$SESS"   # plain text = conversation
esac

Thirty lines, and you already have /help, /clear, /context, /model, and any prompt-command you drop into ~/.lm/commands/. The session is a file — which is the quiet superpower: you can grep it, back it up, diff it, and hand it to n8n.

The Two Commands Worth Doing Properly

`/compact` — the rolling summary, scripted

The single highest-value tool-command. At milestones, the model compresses the session and the console starts fresh with the summary on the board:

# ~/.lm/scripts/compact.sh
SUMMARY=$(ollama run "$MODEL_TAG" """
Summarize this session as a handoff: decisions made, formats agreed,
open questions, next step. Max 120 words.
Session: $(cat "$SESS")""")
: > "$SESS"
echo "## Handoff from previous session" >> "$SESS"
echo "$SUMMARY" >> "$SESS"
echo "compacted — $(wc -w < "$SESS") words on the board"

Run it at milestones, not when the window is already choking — a summary of a cluttered board inherits the clutter. This is the same rolling-summary discipline from context management, now one keystroke instead of a ritual.

Skills are just files — and the folder is the menu

Your multi-step playbooks (the deploy checklist, the PR review rubric, the client-report format) become prompt-commands the moment they're saved as markdown:

# ~/.lm/commands/review-pr.md
Review this diff as a payments-service maintainer.
Order findings by severity. Check: error handling on network calls,
currency rounding, secrets in logs, missing tests for changed branches.
Describe fixes; do not rewrite code.

And because /help is just ls, the menu grows itself. The discipline that makes skills valuable is treating them as software: when a command's output disappoints, you edit the file — the command gets sharper forever. A skill nobody refines is a macro nobody debugged.

One Console for Humans and Machines

Here's the payoff unique to owning the layer: n8n calls the same commands you do. The console becomes the single control surface for the whole stack — your fingers and your automations speak identical syntax:

workflow: nightly-session-reset
schedule: "0 2 * * *"
nodes:
  - name: compact
    type: execute-command
    command: "lm /compact"
  - name: queue-morning-brief
    type: execute-command
    command: "lm /skill morning-brief"
  - name: run-brief
    type: http-request
    url: "http://localhost:11434/api/generate"
    body: { model: "${MODEL_TAG}", stream: false, prompt: "{{session}}" }
  - name: deliver
    type: telegram
    message: "{{brief}}"

Every automation you build this way inherits every command improvement automatically — refine /skill morning-brief once, and both your manual runs and the 2 a.m. cron get the upgrade. No vendor console required, and the whole interface is grep-able text.

Pitfalls, Ported Over

The cloud operators learned these the expensive way; you can skip to the conclusions:

One command per turn. Don't stack /compact and /skill in a single breath — each command mutates session state, and stacking makes the result order-dependent and hard to debug.
Compact at milestones, not at the wall. Summarizing a healthy session preserves the story; summarizing a drowning one preserves the chaos.
Skills are software. Version them, edit them, delete the ones you don't use. A commands folder with 40 stale files is a menu you can't trust; ten sharp ones is an operator's console.

Make It Practical Tonight

Write the launcher (or paste the one above), create ~/.lm/commands/, drop in your single most-retyped instruction as the first .md.
Add /compact this week — it's the command that pays for the whole console.
Move one recurring n8n prompt onto a /skill file so a human and a cron share it.
Retire one clipboard-history ritual for good. That's the feeling of operating instead of re-typing.

The chat apps gave the world a conversation. The CLI tools gave operators a console. Your local stack deserves the second one — and unlike the models, it's yours to keep.

Frequently Asked Questions

Isn't this just aliases and scripts I could write anyway?
It is — deliberately. The value isn't a novel technology; it's the convention: one dispatcher, one commands folder, one session file, three command species. Aliases accumulate as an unstructured pile; the console pattern keeps prompt state, tool state, and connectors separated, which is what makes behaviors like "/help lists everything" and "n8n calls the same command" fall out for free.

How is this different from just using a chat UI with saved prompts?
A chat UI keeps the prompts in its own database and the session in its own memory. The console keeps both as plain files — so sessions are diffable, commands are versionable, the whole surface works over SSH, scripts compose it, and nothing is locked behind an interface that will be redesigned next quarter.

Can I do the confirmation-safety thing for tool-commands?
Yes, cheaply: wrap dangerous dispatches in a read-prompt when the terminal is interactive, and require an explicit --yes flag otherwise. The asymmetry rule from the design section becomes mechanical: prompt-commands fire freely; tool-commands that mutate sessions or switch engines confirm first — including when n8n calls them.

What about multi-step skills that need real logic, not just a prompt?
Let the species compose: a skill file can instruct the model to invoke connector-commands at each step, or the dispatcher can run a small script that chains several commands. Prompt logic for judgment-heavy flows, script logic for deterministic ones — the same division you already use everywhere else in the stack.

Slop Has Fingerprints: How to Recognize AI Writing Anywhere

Peak — Thu, 03 Sep 2026 03:50:59 +0000

You've read a hundred of them by now — the blog post that starts "In today's fast-paced world," balances every claim with a "however," calls a spreadsheet a "tapestry," and ends by summarizing what you just read back to you. Polished, punctual, and completely empty. That's slop, and once you can name its fingerprints, you see it everywhere: in your inbox, in your feed, sometimes — uncomfortably — in your own drafts.

Here's the twist that makes this skill double-sided. The same fingerprints that let you spot slop in other people's content also tell you what to scrub from your own. And the reason the skill matters more than ever: the detectors can't be trusted to do it for you.

The earlier guide on this blog covered the writer's side — measuring your drafts (sentence variance, stock-word density) and repairing them. This one is the recognition side: the full fingerprint kit for spotting machine-flavored text anywhere, why detection tools fail at the same job, and the human-voice markers that separate assisted writing from published slop.

:::answer
AI slop shows recognizable fingerprints: stock vocabulary (delve, tapestry, leverage, harness, robust, pivotal), uniform sentence lengths with low "burstiness," balanced non-committal stances, abstract details instead of named specifics, and packaging filler — pre-summaries, restated conclusions, polite sign-offs. Recognize it by scanning for those markers; avoid producing it by adding specific names and numbers, varying sentence rhythm, using contractions and asides, and deleting the packaging. Detection tools are unreliable judges — pattern recognition by a human editor is the dependable test.
:::

Why the Detectors Can't Save You

The tempting move is to outsource slop-spotting to an AI detector. Resist it. Detectors look for statistical patterns, and the populations overlap badly at both ends: non-native speakers and methodical writers get flagged as machines; a lightly-edited AI draft skates through as human. A tool that misfires in both directions isn't a judge — it's a coin with a user interface.

The real cause of slop isn't the model anyway. It's the prompting. Give a model minimal instructions and it defaults to its statistical middle: polite, balanced, slightly verbose — the exact texture everyone recognizes. Slop is what unedited defaults look like. Which means both recognizing it and avoiding it are learnable pattern skills, and the patterns are specific.

Fingerprint 1: The Lexicon

Individual words prove nothing; word frequency proves a lot. The slop lexicon, in families:

Overworked verbs: leverage, delve, harness, synergize, underscore, uphold, transform
Flowery nouns: tapestry, landscape (figurative), symphony, myriad, realm
Inflated adjectives: pivotal, crucial, seamless, robust, transformative, game-changing

One "delve" is a style choice. Three per page is an unedited draft. These words share a function — each is a placeholder for a thought that never got specific. Where a human writes "the invoicing mess," slop writes "operational friction across the financial landscape."

Fingerprint 2: Flat Rhythm (Low Burstiness)

Human writing bursts — a forty-word sprawl, then four words. Then another long one, because the thought genuinely unfolds that way. Model defaults produce a steady 15–20-word drumbeat, paragraph after paragraph, section after section. Nothing lands because nothing arrives — there's no short sentence doing percussion.

Structural tells ride along: repeated transition scaffolding ("In this section...", "As we have seen..."), the pre-summary that announces what the piece will say before saying it, and the safety wrap — a conclusion that restates the body plus a polite sign-off nobody asked for.

Fingerprint 3: Hollow Specificity

The deepest tell. Slop is specific about nothing:

Slop phrasing	Human phrasing
"a local business"	"the print shop on Silom Road, third floor"
"significant growth"	"400 users in June, 1,200 by December"
"a variety of tools"	"n8n for routing, a Google Sheet as the queue"
"many experts agree"	"every ops lead I interviewed this quarter"

And the anecdotes are too useful — a story that serves the point perfectly, with no tangents, no wrong turns, no irrelevant detail. Real experience leaves skid marks. Generated experience arrives valet-parked. Add the tell-tale balance: every claim immediately hedged with "however, on the other hand" until the piece commits to nothing.

The Quick Spot-Scan

Reading anything suspicious, run the 30-second check:

1. Lexicon: any delve/tapestry/leverage/robust? count them
2. Rhythm: are nearly all sentences 15-20 words?
3. Packaging: pre-summary? restated conclusion? polite sign-off?
4. Specificity: one named number, tool, or place in the whole piece?
5. Stance: does it commit to any opinion at all?

3+ hits = slop. Publish nothing that scores it on your own drafts.

For your own writing at volume, the same scan runs as a local pass — a small model flagging lexicon hits and uniform paragraphs, with client work never leaving the machine. The human makes the call; the machine does the counting.

Keeping Your Voice When the Machine Helps

Using AI and publishing slop are different activities, separated by a few deliberate habits:

Feed specifics in. The model can't invent your reality. "The team saw significant growth" is what you get from a vague brief; "between June and December we went from 400 to 1,200 users" is what you get from giving it the numbers. Garbage briefing, garbage output — the fingerprint was yours first.

Burst on purpose. After a long explanatory sentence, drop a short one. Three words if you like. The rhythm is the register of a person speaking.

Strip the packaging. Delete the hook that opens "In today's fast-paced world," the conclusion that restates the body, and any sign-off hoping the piece helped. If the sentence adds no information, it's wrapping paper.

Reintroduce the human markers. Contractions ("don't," not "do not"). Parentheticals — (I checked three sources before claiming this). Minor flaws, occasionally: the sentence that runs a little long because the thought deserved it. Editors smooth these out; humans put them back.

Commit to a stance. Slop hedges everything. A take — even a modest, defensible one — is the single strongest anti-slop signal available, because the statistical middle never has one.

Frequently Asked Questions

What's the difference between AI assistance and AI slop?

Assistance is using the tool to organize, outline, and draft — with your judgment curating what ships. Slop is publishing the default output: its phrasing, its structure, its non-committal balance, unedited. The tool is the same; the oversight is the difference.

Why does AI-generated prose sound boring?

It optimizes toward the middle of its training data, and the middle is smooth. No lived experience means no vivid imagery, no cost to being wrong, no reason to be brief. Boring is what averaging looks like in text form.

Can I quickly tell if something is AI-written?

Scan for the cluster: sterile contractions-free prose, both-sides hedging, stock lexicon, uniform rhythm, zero named specifics. No single marker convicts — the combination does. And remember the reverse test fails too: some humans write like this, which is exactly why detectors struggle.

Should I run my drafts through an AI detector?

As a curiosity, maybe; as a gate, no. The detector misfires on real humans and misses edited machine text. The 30-second pattern scan above — run by you — is more reliable, costs nothing, and doubles as your editing checklist.

Wrap-Up

Slop isn't a technology problem; it's a defaults problem, and defaults have fingerprints. Learn them once — the lexicon, the flat rhythm, the hollow specificity, the packaging — and you'll spot the stuff everywhere, including your own drafts. Then flip the kit around: feed the machine specifics, burst your rhythm, strip the wrapper, keep your contractions and your stance. Detection tools will keep failing at this job. You don't have to.

DEV Community: Peak

The Google Business Profile Audit: A Room-by-Room Walkthrough

The Google Business Profile Audit: A Room-by-Room Walkthrough

Room 1: Identity — Who Google Thinks You Are

Room 2: Completeness — Every Field Filled or Deliberately Empty

Room 3: Reputation — What Customers See and Say

Room 4: Media — The Room Everyone Photographs Badly

Room 5: Technical Health — The Room Behind the Walls

Scoring the Walkthrough

Frequently Asked Questions

How often should I audit my profile?

Can I pay someone to do this audit?

What's the most common audit finding in Bangkok businesses?

Will fixing audit findings change my ranking?

Stop Retyping Everything: A Slash-Command Console for Your Local LLM Stack

Three Species of Command

The Translator: Cloud Command → Local Equivalent

Build the Launcher

The Two Commands Worth Doing Properly

/compact — the rolling summary, scripted

Skills are just files — and the folder is the menu

One Console for Humans and Machines

Pitfalls, Ported Over

Make It Practical Tonight

Frequently Asked Questions

Slop Has Fingerprints: How to Recognize AI Writing Anywhere

Why the Detectors Can't Save You

Fingerprint 1: The Lexicon

Fingerprint 2: Flat Rhythm (Low Burstiness)

Fingerprint 3: Hollow Specificity

The Quick Spot-Scan

Keeping Your Voice When the Machine Helps

Frequently Asked Questions

What's the difference between AI assistance and AI slop?

Why does AI-generated prose sound boring?

Can I quickly tell if something is AI-written?

Should I run my drafts through an AI detector?

Wrap-Up

`/compact` — the rolling summary, scripted