JTCJTC Tech

// Pillar 05 · Vibe Coding

Directing the agent,not just trying it.

Shipping real software by directing an AI coding agent — not typing every line. The gap between a team that has tried it and a team that ships with it is a workflow, a set of guardrails, and a shared view of what it's for.

// The gap

You tried it.
Did it stick?

Most teams now have someone who has run a coding agent on something real. Far fewer have review and testing that hold for AI-written code, a way for a second person to do it, and an honest position on what it's good for here. That's the difference between a demo and a capability.

What enablement means here

Is a working way to direct the agent, the guardrails that keep its output safe, and getting it into more than one pair of hands.
Not replacing engineers, or letting AI-generated code merge unread. The person who prompted it still owns the diff.
Works across workflow, guardrails and fit — a weak one undermines the other two.
From someone who builds this way in-house — the JTC tools were shipped by directing an agent inside a real process.

// The model

Three things to
get right

01

Workflow

The agent set up, the repo giving it context, people knowing when to reach for it, and how to stop and redirect it when it drifts.

02

Guardrails

Human review before merge, the same test bar as hand-written code, clear ownership of the diff, and scope control.

03

Fit & spread

More than one person capable, a safe path for non-technical people, and a shared position on what it's for.

A slick workflow with weak guardrails ships fast, unreviewed risk. Strong guardrails with no workflow just adds friction nobody uses.

// 01 · Workflow

What good looks like

A coding agent is actually set up and in use — by more than one person, not one champion.
Repos give the agent the context it needs — conventions, how to run tests, what not to touch.
People know when to reach for the agent and when to just write the code.
Prompts and sessions are treated as a skill people get better at — patterns get shared.
When the agent goes down a wrong path, people know how to stop, reset and redirect — not start over.

// 02 · Guardrails · the risky one

Non-negotiable,
not optional

Every AI-generated change is reviewed by a human who understands it before it merges.
AI-generated code passes the same tests — and ideally new ones — as hand-written code.
The person who prompted it owns the diff — its correctness, its security, its fit.
Scope control stops the agent touching secrets, prod config, unrelated files.
AI-generated code gets a security pass — injection, secrets, unsafe dependencies — as standard.

// 03 · Fit & spread

A capability,
not a trick

More than one person can do it — it doesn't leave if they leave.
Non-technical people have a safe path for the right things — internal tools, prototypes, scripts.
Agentic coding sits in the real delivery process — branching, review, CI — not a side experiment.
There's a shared view of what it's good for here — and what it isn't.

// Why the three, together

One weak area
exposes the rest

Workflow without guardrails — fast, confident output that nobody has really checked.
Guardrails without workflow — a review gate on code the agent produced badly, so people stop bothering.
Fit without either — one person's party trick, one leaver away from gone.

Find the weak one and reinforce it first. That's the engagement in a sentence.

// The failure modes

Where teams
get exposed

Merge-and-hope — AI-written PRs get a lighter look than hand-written ones.
The lone champion — it works, but only when one person drives it.
Context starvation — no agent-facing docs, so every session re-explains the codebase.
Scope creep — the agent edits files, config and secrets it was never meant to touch.
Side experiment — it never joins the real branch-review-CI process, so it never matures.

// The starting point

The readiness check

14 questions — about four minutes, scored in the browser.
A score for workflow, guardrails and fit — and a combined grade from Experimenting to Fluent.
A concrete first move for each area.
Take it before the first conversation: jtctech.co.za/assess-vibe

It measures how the team ships with an agent — not how good anyone is at prompting.

// How an engagement runs

Set up → guard → spread

01

Readiness check

Score workflow, guardrails and fit. Name the weak one.

02

Set up the workflow

Agent installed, agent-facing docs in the repos, shared patterns for prompting and redirecting.

03

Put the guardrails in

Review rule, test bar, diff ownership, scope control, standard security pass.

04

Spread & embed

Pair-build on the live codebase, a safe non-technical path, and it lives in normal delivery.

// By segment

Where it starts

Individuals

Get directing

Claude Code onboarding and first project · vibe-coding fundamentals · a prompt-to-prototype clinic.

SMB

Make it a team habit

Team Claude Code rollout · an AI-generated-code review and guardrail workflow · pair-building on a live codebase.

Enterprise

Operating model

An agentic-coding operating model · standards for AI-generated code at scale · enablement across engineering teams.

// What an engagement leaves behind

What you keep

The setup

Agent-ready repos

Agent-facing docs and shared prompt patterns that make every session start from context, not cold.

The rule

"You own the diff"

Human review, the same test bar, a security pass, and scope control — enforced in review, not aspirational.

The position

"What it's good for here"

A written, shared view of where agentic coding fits and where it doesn't — revisited as the tools change.

// Why JTC

We ship this way
ourselves.

The JTC tools — Guardian AI, PromptForge, Dark Pattern Detector, Scrum Toolkit — were built by directing an agent inside a real review-and-test process.
Led by Jon Boyle, who has lived the AI and Agile adoption curve inside a real team at scale.
Guardrails first — the advice is what we actually enforce on our own diffs, not a theory.