# AI Engineering Training Recommendations for Northcove

Based on interviews with **Nina** (Full Stack), **Ben** (Senior Software Engineer, Business group), and **Raj** (Engineering leadership context), the following cross-cutting themes emerged. Below is a prioritized recommendation for training focus areas.

---

## 1. Context Engineering & Knowledge Management

**Why it matters:** All three engineers independently identified context as the #1 bottleneck. Poor documentation, scattered knowledge (Confluence, Slack, Google Docs, stale repos), and inability to feed company-specific context to AI tools consistently degrades output quality.

**What to train:**
- Techniques for tagging relevant files upfront when prompting (Ben: *"don't just say 'do the thing'"*)
- Building and maintaining structured system prompts with coding standards, framework versions, and architectural conventions
- Using project-level rules files (e.g., `AGENTS.md`, `.cursorrules`) to encode Northcove-specific patterns
- Strategies for keeping context artifacts fresh alongside code

---

## 2. From AI-Second to AI-First Workflow Integration

**Why it matters:** Ben describes most of the org as still in "AI-second" mode. Raj notes the team has transitioned to "editors rather than authors" but agents are still underutilized. There's an appetite to go further.

**What to train:**
- Practical AI-first patterns: using AI for planning, debugging, reproduction, documentation, and one-off scripts — not just codegen
- Embedding AI into daily rituals: standups, ticket creation, code review prep
- Knowing *when* to use AI vs. when to write manually (correctness-critical, regulated data, database migrations)
- Organizational playbooks for reusable prompts and commands (Ben's recommendation)

---

## 3. Prompt Engineering Beyond Chat

**Why it matters:** Nina identifies herself as a "basic user" and wants better prompt engineering for incremental changes. Ben is experimenting with DSPy and subagents but hasn't operationalized them. There's a spectrum of skill that training can level up.

**What to train:**
- Structuring prompts for incremental, surgical edits vs. big batch generation (Nina's pain point)
- Providing concrete examples from the codebase rather than abstract descriptions (common failure pattern)
- Techniques for prompt iteration and evaluation (especially for LLM-powered features like Nina's document interpretation system)
- Introduction to automated prompt optimization (DSPy, prompt management tools)

---

## 4. Testing, Validation & Guardrails for AI-Generated Code

**Why it matters:** Nina worries about "plausible but subtly wrong" code and a lack of robust end-to-end testing. Raj flags compliance risks with regulated data exposure. Ben notes he can't use AI for production features because of hidden side effects and coupling.

**What to train:**
- Building verification workflows: AI generates code → human-approved test plans → automated validation
- Techniques for generating test suites alongside code changes
- Identifying high-risk areas where AI output needs extra scrutiny (database migrations, financial calculations, regulated data)
- Monitoring and evaluation systems for AI-generated code in production
- Data exposure awareness when using third-party AI models

---

## 5. Agent Workflows & Background Automation

**Why it matters:** All three show interest in moving beyond chat and tab-complete toward autonomous agents. Nina wants long-running background processes for feature development. Ben uses agents for test coverage and feature flag removal. Raj notes agents are less adopted but early adopters are experimenting.

**What to train:**
- When to delegate to an agent vs. work interactively
- Structuring tasks for autonomous execution: clear scope, success criteria, boundaries
- Patterns for background agents: test writing, refactoring, code cleanup, documentation sync
- Safety mechanisms: sandboxed execution, review gates, rollback plans

---

## 6. Code Review Mindset for AI Outputs

**Why it matters:** The team is "editors rather than authors" (Raj). This shifts the skill required from *writing* code to *evaluating* code — a different muscle.

**What to train:**
- Reviewing AI-generated code with appropriate scrutiny levels based on risk
- Recognizing common AI failure patterns: over-engineering, wrong context cherry-picking, plausible but incorrect logic
- Balancing speed (AI generates faster) with quality (human review must adapt)
- Building checklists for AI code review tailored to Northcove's stack and compliance requirements

---

## Suggested Training Format

| Module | Audience | Format | Estimated Time |
|---|---|---|---|
| Context Engineering | All engineers | Workshop + hands-on rules file creation | 2 hours |
| AI-First Workflows | All engineers | Lunch & learn + team playbooks | 1 hour |
| Prompt Engineering | Intermediate users (Nina's cohort) | Hands-on lab with real Northcove code | 2-3 hours |
| Testing & Guardrails | All engineers + QA | Workshop + checklist creation | 2 hours |
| Agent Workflows | Power users (Ben's cohort) | Demo + guided sandbox experimentation | 2 hours |
| Code Review for AI | All engineers | Pair-review sessions + guidelines doc | 1.5 hours |

---

## Quick Wins (Do First)

1. **Create a Northcove `.cursorrules` / `AGENTS.md` template** with stack versions, architectural patterns, and compliance notes — every engineer can adopt immediately.
2. **Run a "context sprint"** where each team documents its top 5-10 conventions in a machine-readable format.
3. **Establish an internal Slack channel** (Ben's `cursor-nerds` model) for sharing effective prompts and agent recipes.
4. **Pick 2-3 agent use cases** (test generation, feature flag removal, docs sync) and run a pilot with Ben's cohort, then socialize results.

---

*Assumptions: Northcove uses Python/TypeScript on a monolithic architecture, has ~100 engineers, and operates with strong engineering autonomy and continuous deployment. Training should accommodate 4-10 years experience range and varying levels of AI skepticism.*