Ai

From Rigor to Tool: Applied AI Without Losing the Research

Rigorous research changes minds. A tool changes behavior. The gap between the two is where most research dies — and where applied AI is most tempting and most dangerous, because the easy version strips out the rigor that made the research worth trusting.

Turning research into a usable tool means putting findings in front of people who will act on them. Applied AI can close that gap — or quietly launder away the rigor. Where it fits, and how to keep the research intact.

Hiring for Capability: Applied AI and the Skills-First Bet

Skills-first hiring promises to judge people on what they can do, not the credentials they happen to hold. Doing that at scale means making fast judgments about capability — and that is exactly where applied AI helps, and exactly where it can do the most damage.

Skills-first hiring asks software to judge capability, not credentials. That is a judgment problem, not a filtering one — and the bias and explainability burden is the whole game. Where applied AI fits, and where a human still decides.

Reading the Law as It Moves: Applied AI for Legislative Intelligence

Legislation is a firehose of messy, fast-changing text where a single amended clause can flip what a bill means. Tracking it is a judgment problem, not a search problem — and that is exactly where applied AI helps, and exactly where a confident wrong reading can cost an advocacy campaign everything.

Legislative tracking is judgment over messy, fast-moving legal text, not keyword search. Where applied AI fits, why explainability is non-negotiable for advocacy decisions, and where a human still reads the clause.

Productizing the Insight: Applied AI for Innovation Consultancies

A consultancy's product is judgment that does not scale — senior strategists reasoning through a hard problem one engagement at a time. Applied AI can productize the scaffolding around that judgment. Confuse the two and you automate away the only thing clients were paying for.

Innovation consultancies sell judgment that resists scale. Applied AI can productize the repeatable scaffolding around it — without automating the strategic reasoning that can't be commoditized. Where the line goes, and how to draw it.

Cohorts, Employers, and Livelihoods: Applied AI for Workforce Operations at Scale

Run a workforce program at national scale and you're orchestrating two matching problems at once — people into cohorts, graduates into jobs — across thousands of lives. The operations are crushing and repetitive. The decisions inside them change whether someone gets a livelihood. Applied AI can carry the first without touching the second.

Workforce programs match people into cohorts and graduates into jobs, at scale, where a wrong call affects a livelihood. Here's how applied AI handles the operational load while humans keep the consequential decisions — plus a two-day way to start.

When Your Judgment Is the Product: Applied AI for Strategy and Policy Firms

For a strategy or policy firm, the asset isn't a process — it's the judgment of the people in the room. That makes "productize it so it scales" a dangerous instruction, because the obvious way to scale judgment is to dilute it. Applied AI offers a different path: scale everything around the judgment so the judgment itself can go further.

When the product is expertise and the moat is a community, scaling usually means diluting the very thing clients pay for. Here's how applied AI scales the work surrounding judgment without replacing it — and a two-day way to start.

Matching Help to Need: Applied AI in a Marketplace Where Being Wrong Has a Cost

A marketplace that connects people who need help with people who can give it has a brutal constraint most marketplaces don't: a bad match isn't a refund, it's a person who walked away worse off. Applied AI can do the triage and quality work at the speed the moment demands — if you build it knowing where being wrong is expensive.

In a help marketplace, latency and a bad match both have a human cost. Here's how to use applied AI for triage and quality — fast where speed is safe, human where being wrong is costly — and a two-day way to start.

Packaging a Proven Model: Applied AI Without Flattening What Made It Work

Organizations that spent two decades perfecting a method face a cruel paradox when they try to scale it: the moment you write the model down so others can run it, you risk losing the judgment that made it work. Applied AI can carry the procedure without flattening the practice — but only if you separate the two on purpose.

A model refined over twenty years is mostly tacit judgment. Productizing it usually flattens it into a checklist. Here's how to use applied AI to scale the procedure while keeping the judgment human — and a two-day way to start.

From Marketplace to Operating System: Applied AI and the NIL Back Office

The first wave of NIL software solved discovery — match an athlete to a brand. The revenue-sharing era turned NIL into an ongoing operation someone has to run. Marketplaces don't run operations. Operating systems do, and that's where applied AI earns its keep.

Discovery in the NIL economy is solved. The unsolved, expensive part is the back office — deals, disclosures, compliance, payments — at scale. Here's where applied AI fits, and where judgment still has to win.

Applied AI in Sports Media: When Every Athlete Is a Distribution Channel

Teams and leagues are expected to produce thousands of personalized clips a week for athletes who each out-reach the old broadcast networks. The supply of moments hasn't changed; the demand for content cut from them has exploded. That gap is where applied AI earns its keep — or gets built badly.

The athlete became the distribution channel, and almost no one can feed that channel by hand. Here's where AI actually fits in sports media — and where judgment still has to win.

The Future of AI in College Athletics: What NIL Taught Us About Building for Chaos

NIL turned college sports into a fast-moving, lightly-governed market overnight. That's exactly the kind of mess AI is good at — and exactly the kind of mess that punishes software built without judgment. Here's where we think AI actually fits.

HARNESS: Turning AI Fog Into a Buildable Idea

AI made it easier to generate ideas. That is not the hard part anymore. The hard part is turning a fuzzy possibility into something a team can actually evaluate, scope, and build.

After Boulder Startup Week, the thing that kept sticking with me was not that teams need more AI ideas. They have plenty. What they need is a way to turn the fog into a real product shape. That is what the HARNESS Canvas is for.

The Agent Stays Up Late, Not Me

Every senior engineer knows the right way to set up a codebase. None of them do it. Here’s the four-stage framework we use — The Ratchet — to take a vibe-coded project all the way to a thing you’d trust in production, and the punchline about why this only just became worth doing.

Most teams have always known they should be running tests, type-checking, security audits, accessibility checks, dead-code analysis, prose linting, and a coverage floor. Most teams run two of those. Here’s why that math has finally inverted, and the four-stage framework we use to ratchet a vibe-coded project to a hardened one.

Two Kinds of Google Keys, Two Endpoints

The Gemini key that rejects your request with 403 API_KEY_SERVICE_BLOCKED is almost certainly a Vertex key being sent to the AI Studio endpoint. Here is how to tell them apart, and which endpoint to use.

We spent an hour chasing what looked like a billing issue and turned out to be a key-format mismatch. The key worked. Google was just telling us we had pointed it at the wrong building. If you are shipping a Gemini integration, this is the one-page reference we wish we had read first.

Design Tokens as Prompt Anchors

When you hand a generative image model an adjective, it drifts. When you hand it your design-system tokens by exact hex, it stops drifting. The discipline we found after shipping it wrong once.

We shipped the first cut of our CMS image generator with preset language like "hand-drawn whiteboard sketch" and "muted red accent." The output was childish chalkboard stick figures — nothing like the pen-and-ink illustrations already on our blog. The fix was not a better adjective. It was the same move you use everywhere else in design: stop naming things with vibes, start naming things with tokens.

Context Laundering

The one use case where spawning a sub-agent always pays off. It is not parallelism. It is triage for your main context window.

We use the word parallelism when we talk about sub-agents. Most of the time we are not actually running in parallel. We are protecting the main context from heavy reading. That is the move.

Red/Green TDD When Your Dep Is a Generative API

How to test-drive code that integrates with Gemini, Claude, or any non-deterministic API — without pretending the API is deterministic.

Gemini does not care about your unit tests. But your unit tests can still be green, fast, and trustworthy — if you put the seam between your code and Gemini in the right place. Here is the pattern we used to ship a CMS image-generation feature in under a day, with every layer TDD'd and the Gemini boundary mocked without hand-waving.

Explaining Claude Code to a Non-Technical Audience

What Claude Code actually is, why it changes how work gets done, and where it fits in a business (and where it doesn't).

If your engineers keep mentioning Claude Code and the name alone does not tell you much, this is the plain-English explanation. What it is, why it is different from a chatbot, and where it actually fits.

How to Access Claude Code in Your Organization

Starter paths from a solo developer trying it over lunch to a full company rollout with billing, auth, and audit in place.

Getting Claude Code into your team doesn't have to start with a committee. Here are the paths we've watched work, from a single dev with a free trial to a company-wide rollout with governance and audit, plus the first 30 days we'd actually run.

The Sub-Agent Skill Trap

Spawning a sub-agent looks like the obvious move for any multi-step task. Half the time it is the wrong one, and the signals are quieter than you think.

Sub-agents feel like leverage: one call, many workers, results in parallel. But most of the time we reach for one, the work was never parallel to begin with. Here is how to spot the trap before you fall in.

When to Use What: Choosing the Right Claude Code Harness for the Task

Hooks, skills, CLAUDE.md, MCPs, sub-agents, plan mode. A practical decision framework for picking the piece of the harness that actually earns its keep on the task in front of you.

Claude Code gives you six different ways to shape a session. Most teams reach for the wrong one and wonder why the loop feels slow. Here's how we decide, task by task, which piece of the harness is worth the setup cost.

How to Share Claude Code Skills Across Repos, Teams, and Clients

Skills are the new unit of institutional knowledge. Here's how we package, share, and govern them across a studio that runs on Claude Code.

Claude Code skills are reusable slash-command workflows. Once they exist, the question is who gets to use them: you, your team, your org, or a specific client. Here's the sharing model we run at Black Flag and the disciplines that keep it from rotting.

What Designers Need to Know About Claude Code

Claude Code isn't just an engineering tool. For designers, it's the fastest path we've found from a Figma frame to a production-quality build, if you know what to feed it.

Designers asking whether Claude Code is for them: the answer is yes, but not the way engineers use it. Here's what a year of design work in Claude Code taught us: the habits that translate polished intent into shipped UI without losing the craft.

What a Year of Claude Code Trails Tells You About Your Team

Claude Code leaves evidence — sessions, commits, PRs, review notes. Read it like a logbook and you'll find what devs actually need to know before they go deeper.

After a year of shipping with Claude Code across real client work, the signal isn't in any single session — it's in the trails. Here's what those trails told us about where Claude Code shines, where it drifts, and the habits devs should build before they lean in harder.

Migrating Mission-Critical LLM Systems from Freeplay to Arize Phoenix

Freeplay shuts down May 15. If evals and traces are in your production loop, here's how to move them to Phoenix without losing the discipline you've built.

Freeplay closes May 15, 2026. For teams with mission-critical LLM systems, this is a forced migration with a hard deadline. A practical plan for moving evals, traces, and review loops to Arize Phoenix — without regressing on the quality signals you rely on.

Six Principles for Shipping Reliable Software with AI

How we stay sane while "vibes" infiltrate codebases — the playbook we run on every engagement.

AI-generated code floods projects with promises of speed and delivers drift instead. Six disciplines turn it back into a reliable tool: small scope, human judgment, repeated purpose, weekly planning, active management, and continuous improvement.

The Black Flag Playbook: Six Principles for Shipping with AI

Battle-tested principles for teams building real software with AI-generated code. Human judgment, tight scope, and weekly evidence — the disciplines that keep AI-built systems reliable.

The six rules we use to ship production software with AI. Small scope, weekly demos, human-led oversight, and continuous improvement — drawn from six months of real client engagements.