Thematic

gpt-6.1-solrun 1 Sep 2026

Instructions

Instructions — the case's current instructions

help me synthesize what to focus on in our AI engineering training for this company based on meeting notes with three engineers

help me synthesize what to focus on in our AI engineering training for this company based on meeting notes with three engineers

7 of 7 checks passed

ANSWER.mdthe model's output · 9.05 KBdownload

What Northcove’s AI engineering training should focus on

Recommendation

Teach engineers how to give AI the right Northcove context, verify its work, and delegate tasks with clear boundaries. The interviews suggest the main constraint is not access to tools or awareness of code generation. It is confidence that AI-assisted work fits a coupled, company-specific codebase and is safe to ship.

Make that the shared curriculum. Offer advanced agent workflows and LLM evaluation separately, so experienced users get depth without making everyone learn capabilities they do not yet need.

Basis and assumptions: This synthesis uses the three interviews in context.md, not a company-wide survey. I assume the primary audience is engineers across Consumer, Business, and Platform, using the existing Python/TypeScript stack and approved tools. The session format below is a proposal; no training duration or budget was specified.

What the interviews tell us

Theme Evidence Training implication
Company context is the clearest shared bottleneck Nina sees AI copy legacy patterns and cannot reliably supply scattered documentation. Ben cannot convey hidden coupling and side effects. Raj says Northcove-specific implementations need prescriptive rules. Make context preparation the first and largest topic—not generic prompt tricks.
Trust depends on verification Nina worries about plausible code and weak integration/end-to-end coverage. Ben works on correctness-critical calculations and limits production-feature use. Raj is skeptical about migrations and regulated-data work. Teach risk assessment, meaningful tests, review, and escalation alongside generation.
Adoption is uneven, and usage is not the same as trust Nina describes basic chat use; Ben is a power user but rarely uses AI for production features; Raj reports widespread code generation but limited agent adoption. Avoid declaring the company either beginner or advanced. Use a common practical exercise, then differentiated clinics.
Delegation is attractive but still immature Nina wants less back-and-forth and larger delegated tasks. Ben is trying background work and subagents. Raj sees only early agent adoption. Teach bounded delegation after context and validation, not autonomous feature delivery as the opening promise.
Some needs are specialist or organizational Nina has a document-interpretation evaluation problem. Ben wants prompt optimization and better planning. Raj highlights meeting load and stale knowledge. Separate specialist training from shared skills, and name the process changes training cannot deliver alone.

Ranked training priorities

1. Build a useful context package for real work

Teach engineers to turn a request into a small, explicit task brief: intended behavior, relevant files, a current example to follow, business invariants, constraints, acceptance criteria, and unresolved questions. Show how to ask the assistant to trace dependencies and surface uncertainty before editing.

Distinguish authoritative conventions from legacy code that merely happens to exist. Practice creating concise, scoped repository guidance with an owner and review date, rather than trying to encode every standard in one enormous prompt.

Exercise: Give participants a sanitized Northcove-style change containing both a preferred implementation and a misleading legacy example. Compare an underspecified request with an explicit context package. Inspect the differences in assumptions, scope, and output.

Takeaway: A reusable task-brief template and a small, reviewed set of repository instructions.

2. Verify AI-generated work according to its consequences

Teach participants to choose the validation standard before generation. A disposable prototype can be directionally correct; invoicing logic cannot. Ben’s tolerance for rough sketches should not become the standard for production changes.

Practice reviewing diffs, identifying affected callers and side effects, and designing tests from requirements rather than from the generated implementation. Use deterministic calculation examples, boundary cases, failure paths, and cross-component behavior. Include a deliberately plausible defect so “tests passed” is not the entire lesson.

Data-handling boundaries belong here too: use sanitized exercises, explain the company’s approved-tool and data rules, and stop or escalate when those rules or the necessary context are unclear. The interviews do not establish what the actual policies permit.

Takeaway: A verification checklist that scales from internal scripts to correctness-critical changes, including when human domain review is required.

3. Turn chat assistance into a repeatable, bounded workflow

Teach a practical sequence: investigate → plan → make a small change → run checks → review → summarize. Practice controlling scope, giving corrective feedback, and requiring evidence of completion. Use this same structure for a supervised task before introducing background execution.

For delegation, define allowed files/actions, non-goals, checkpoints, stopping conditions, and a reviewable handoff. Start with contained work such as reproducing a bug or adding tests. Feature-flag cleanup can be a candidate only after checking dependencies; it should not be presumed safe simply because it sounds routine.

Takeaway: A delegation template and one completed task whose changes and verification another engineer can review.

4. Use AI for scoping and technical alignment

Keep this shorter, but include it. Ben’s overloaded specs and Raj’s engineering-led scoping suggest value before implementation. Nina’s experience with interactive mockups provides an existing example to build on.

Practice producing a concise technical brief, enumerating unknowns, and using disposable prototypes to clarify a decision. Separate alignment on the problem from detailed implementation planning. Summaries should identify source material and unanswered questions, not present assumptions as decisions.

Takeaway: A one-page technical brief with decision, scope, risks, and open questions.

Suggested delivery

Run a pilot with roughly 12–15 engineers spanning all three groups and different experience levels before rolling out to the full organization.

Core workshop block Time
Baseline exercise, task selection, and data boundaries 30 min
Context preparation and repository guidance 90 min
Verification and debugging 90 min
Bounded execution and delegation 60 min
Scoping and technical alignment 30 min
Repeat exercise, review, and team adoption decisions 30 min

This is 5.5 hours of instruction and practice, excluding breaks; it can be split across two sessions. Use one coherent Python/TypeScript example throughout. Ask Ben to contribute a power-user demonstration and Nina to test whether the workflow is accessible, subject to their availability.

Optional clinics:

  • LLM feature evaluation: For engineers building features like Nina’s document interpretation system. Cover label quality, representative evaluation slices, a held-out test set, repeated runs to expose variability, prompt/model version comparisons, and checking whether proxy metrics actually track correctness. Introduce automated prompt optimization only after establishing a trustworthy evaluation loop.
  • Advanced agents and integrations: For experienced users. Extend the core delegation exercise to longer-running work, tool access, and failure recovery. Use tools already approved and working; do not make MCP configuration a prerequisite, given Ben’s reported friction.

What not to make the centerpiece

  • A broad introduction to AI or autocomplete: there is already substantial adoption.
  • A tour of tools, frameworks, and generic prompt recipes: the shared gap is applying them reliably to Northcove work.
  • Unsupervised large features, migrations, or regulated-data tasks: these are precisely where confidence and safeguards are weakest.
  • A company-wide knowledge platform or documentation cleanup: training can establish useful habits and templates, but ownership and maintenance require organizational work.

Follow-through and evidence of success

Before the pilot, obtain sanitized examples, identify current authoritative conventions, and have the appropriate internal owner confirm the data-handling boundaries. Afterward, assign owners to the shared templates and guidance; consolidate useful examples from the existing Slack channels into a maintained reference.

Evaluate the pilot on time to a correctly completed, reviewed task, not generated code volume. Track missing-context mistakes, review rework, and whether participants detect the seeded defect. For the following two to four weeks, collect examples of workflows reused on real tasks, together with review effort and escaped issues. Interpret a small pilot cautiously; it will not prove organization-wide productivity gains.

Success is engineers reliably choosing suitable tasks, supplying necessary context, and demonstrating correctness—not simply using AI more often.