Campus AI Development Building the capacity to experiment

8.1 — Capacity to experiment

Building the capacity to experiment

Most good ideas start as one person’s experiment. The institution decides whether it happens somewhere safe, with the right skills and partners nearby.

Competencies

What matters once building is cheap

Effort moves from writing code to deciding what to build and checking it. This builds on the skills table; the right-hand column says where each skill matters most.

CompetencyWhat it looks likeMatters most for
Writing specs and acceptance criteriaWhat it does, what it doesn’t, how you’ll know it works, written before the agent startsFunctional analysts, enterprise teams, platform makers
Designing verification when not every line is readTests from the spec, protected test files, and diff review for what was removed as well as added. Spec-drivenEnterprise teams, research software engineers
Scoping agentsPermissions, context, budgets and stop conditions set before a runPlatform makers, IT, anyone running agents
Reviewing AI output criticallyIf you can’t explain it, don’t ship itEveryone; faculty teaching it
Knowing the dataIts classification, authoritative source and stewardBusiness users, analysts, researchers
Knowing when not to use an agentHigh stakes, unfamiliar systems, regulated data or no way to check the resultEveryone

Environments

Safe places to experiment

Three tracks, each with its own data rules. Moving between them is the promotion step.

Personal · T1–T2

A sandbox for one person

  • Campus-licensed account, not a personal one
  • Public or synthetic data only
  • No production credentials
  • Throw away or promote
Shared · T2–T3

A team or unit environment

  • Internal data; confidential only with steward approval
  • Version control and a registry entry
  • Named owner and review date
  • Scoped, revocable credentials
Institutional · T3 and up

A managed platform

  • Data as classified, in an approved environment
  • CI gates, tests and security checks
  • Audit logs the builder can’t edit
  • Support path and offboarding plan

Data rules for pilots

  1. 01Synthetic or de-identified firstProve the idea before real records enter it.
  2. 02Real data only where approvedUse the track approved for the data’s level, with steward sign-off at confidential and above.
  3. 03Outputs inherit the classificationA report or export built from confidential data stays confidential.
  4. 04Pilots end cleanlyAt the review date, pilot data is deleted or kept on the retention schedule.

Tools

What to hand builders

People use personal accounts when the approved path is slower. These four things remove most reasons to work around it.

  1. 01A campus-licensed AI assistantAccounts with institutional data terms, granted in days.
  2. 02Low-code and workflow platformsOften the right first tool for forms, approvals and automations. Platforms
  3. 03Version control and starter templatesA shared repository with templates that already include sign-in, logging and accessibility basics.
  4. 04Hosting behind campus sign-inA place to run pilots, so nobody has to stand up their own server.

Over-governing has its own cost; see proportionality and the shadow tool case.

Patterns

Pairings that work in practice

None of these needs a new office. Each puts domain knowledge and technical judgment in the same room.

Pairing

Domain expert + platform partner

The person who knows the work builds; IT or a platform team supplies the environment, credentials, integration and review.

Community

A lightweight community of practice

Builders across units share specs, prompts, guardrails and mistakes. It also shows where tools overlap before they multiply.

Review

Paired review

A second person reviews diffs, tests and data access before others use the tool, scaled to the tier. A research software engineer plays this role for research code.

On campus

Emerson’s shared environment and doctrine

At Emerson, the people building knew the operations; none needed to be programmers. IT leadership supplied a shared approach: a written development plan, the “doctrine,” fed into every AI session, with architecture decisions recorded back into it, and a schema designed before features.

That combination let seven systems reach production. Read the case

Next: when a pilot turns into something others rely on, see scaling to production.