Training: how to write good prompts/tasks

Training in how to write good prompts and tasks is the L2 investment in the fundamental skill that determines whether AI agents are useful or frustrating.

·AI champion is designated per team with allocated time (not just informal interest)
·Context engineer role exists (initial, possibly part-time) for maintaining agent instruction files
·Developer training on effective agent interaction (prompt writing, task decomposition) has been conducted

·Champion has a regular cadence for sharing learnings across the team
·Training materials are documented and available for new hires

Evidence

·Team roster showing designated AI champion with time allocation
·Context engineer role assignment (even if combined with other duties)
·Training session records or materials

What It Is

Training in how to write good prompts and tasks is the L2 investment in the fundamental skill that determines whether AI agents are useful or frustrating. A developer who writes clear, well-contextualized task descriptions gets dramatically better results than one who writes vague, assumption-laden requests - from the same model, with the same tools, on the same codebase. The quality of agent communication is the highest-leverage individual skill in AI-augmented development, and it is teachable.

The skill is not about knowing magic words or memorizing prompt frameworks. It is about three underlying capabilities: decomposing work into appropriately-sized, well-defined units; providing the context the agent needs to do the work correctly; and specifying the success criteria clearly enough that the agent (and the developer reviewing the output) can determine whether the task is done. These are skills that experienced tech leads apply when assigning work to junior developers - the same skills apply when assigning work to AI agents.

What makes prompt writing teachable is that the quality signal is fast and visible. A developer who writes a vague task prompt sees a bad result in 30 seconds. A developer who rewrites it with better context and clearer scope sees a better result in 30 more seconds. This fast feedback loop means that people who engage seriously with the skill improve quickly. The training intervention is not about teaching rules - it's about creating structured practice opportunities where people get the feedback loop, compare good and bad approaches, and develop the pattern recognition for what makes a task description effective.

Training at L2 is typically informal: a workshop, a shared prompt library with examples, a regular "prompt review" in team standup where people share what worked and what didn't. At L3, this becomes more systematic - formalized training modules, onboarding curriculum, and peer coaching structures. But the L2 investment in formal training is the first time the organization acknowledges that this is a skill, not just an intuition, and that it's worth investing in developing it systematically.

Why It Matters

Prompt quality training has a disproportionate return on investment because it affects every developer's AI output:

Multiplies every developer's AI investment - a developer who spends 20% of their time on AI-assisted tasks and writes mediocre prompts is getting perhaps 40% of the value available to them; the same time investment with good prompt skills might yield 80% of the available value; training doubles the return on an existing investment
Reduces senior debugging burden - a significant portion of the "senior debugs AI code" anti-pattern is caused by developers with poor prompt skills generating code with good tools; prompt training upstream reduces the debugging load downstream
Creates a common language for AI collaboration - when a team has shared vocabulary and shared standards for task specifications, developers can review each other's prompts, suggest improvements, and build on each other's patterns; without shared training, each developer develops idiosyncratic approaches that don't transfer
Reveals the task decomposition skill gap - many developers who struggle with prompt writing are actually struggling with task decomposition - the ability to break work into well-defined, appropriately-scoped units. Prompt training surfaces this gap and the skill development addresses it for both human and agent collaboration
Accelerates the transition to L3 - the prompt skills developed at L2 are the foundation for the more sophisticated task specification needed at L3, where agents run more autonomously and the cost of a poorly specified task is higher

Tip

The best prompt training exercise is comparative: take a real task from the team's current backlog, write three versions of the task specification (vague, good, excellent), run all three through the agent, and compare the outputs in a group setting. The comparison makes the skill concrete in a way that abstract rules cannot.

Getting Started

Start with task decomposition, not prompt syntax - before teaching anyone specific prompt patterns, ensure the team can decompose work into well-defined units. A task like "improve the performance" is not a prompt failure - it's a decomposition failure. Practice: take a vague task description and break it into three or four specific, independently-testable sub-tasks. This is the foundation.
Build a "before and after" prompt library - collect real examples from the team of vague prompts that produced bad results and improved prompts that produced good results for the same task. A dozen of these examples, organized by task type (implement a feature, write a test, refactor a function), is more effective training material than any abstract guide.
Run a weekly prompt review - add 10 minutes to a team meeting for one developer to share a prompt they wrote that week, the result it produced, and either what they'd do differently or why they were satisfied. Over time this creates a shared vocabulary for prompt quality and a culture of continuous improvement.
Create a task specification template - design a simple template for common AI task types: [Task Type] | [Context: what the agent needs to know] | [Scope: what's included and excluded] | [Success criteria: how will we know it's done] | [References: existing files or patterns to follow]. A template reduces blank-page anxiety and ensures the most common context omissions are caught.
Train specifically for high-value task types - don't try to teach prompt writing in the abstract. Focus on the three or four task types that represent most of the team's AI usage: "write unit tests for this function," "implement this API endpoint following existing patterns," "refactor this class to improve X." Deep practice on common task types is more valuable than shallow coverage of all cases.
Measure training impact - before and after training, ask developers to rate their confidence in writing effective AI prompts (1-5 scale) and measure agent error rates on their code. If training works, confidence should rise and error rates should fall. Simple before/after measurement creates accountability and evidence for the investment.

6 steps to get from here to the next level

Common Pitfalls

Teaching prompt frameworks instead of prompt thinking. There are dozens of "prompt engineering" frameworks online - RISEN, COSTAR, etc. Teaching a framework is not the same as teaching the skill. Frameworks are scaffolding for people who don't yet have the underlying intuition; they should be temporary support, not the permanent goal. The goal is developers who can write effective task specifications without consulting a cheat sheet.

Making training a one-time event. Prompt writing is a skill that develops through practice over time, not a body of knowledge that can be transferred in a single workshop. A two-hour workshop without ongoing practice and feedback will produce short-term awareness and long-term reversion to old habits. Design training as a 6-8 week program with weekly practice exercises, peer feedback, and visible measurement.

Focusing on individual prompts rather than prompt systems. The highest-value prompt training outcome is not better individual prompts - it's better prompt templates and patterns that the whole team can reuse. Train developers to think in terms of "what prompt pattern works for this category of task?" and encourage them to contribute their discoveries to the shared template library.

Ignoring the context provision skill. Many prompt training programs focus on how to phrase the task request and ignore how to specify the context the agent needs. Context provision is at least as important as task phrasing. Training should explicitly cover: how to identify what context an agent needs for a given task, where to find that context in the codebase, and how to include it efficiently without overwhelming the context window.

Not connecting training to team-specific conventions. Generic prompt training teaches general principles. It becomes dramatically more valuable when combined with team-specific content: "for our codebase, when writing prompts about the payment service, always reference the PaymentProcessor interface and include the error handling requirements from CLAUDE.md section 3." Team-specific prompt training requires team-specific context engineering to have happened first.

Mistakes teams actually make at this stage - and how to avoid them

How Different Roles See It

BobHead of Engineering

Bob's team is at L2 with patchy AI tool adoption - some developers use AI tools effectively and produce good results, others use the same tools and produce mediocre results. When Bob asks what separates the effective users from the ineffective ones, the effective ones describe their approach to structuring task specifications. The skill gap is visible but not addressed.

What Bob should do: Bob should commission a half-day prompt writing workshop led by the team's best AI practitioners (the organic champions). The workshop should be structured around three real tasks from the team's current backlog: write a bad prompt, see the bad result, write a better prompt, see the better result, discuss what changed. Bob should follow the workshop with a four-week practice period where developers write one deliberately well-crafted AI task per day and share their best example in a team Slack channel. At the end of four weeks, measure whether agents' error rates in PRs have declined. This sequence - workshop, practice, measurement - is a complete intervention that produces a measurable capability improvement.

What Bob should do - role-specific action plan

SarahProductivity Lead

Sarah has been asked to design an AI skills curriculum for 120 engineers across 15 teams. The curriculum needs to cover the full range of AI-related skills from basic tool use to advanced agent orchestration. She's been told to start with "prompt writing" but is unsure how to scope and sequence it.

What Sarah should do: Sarah should design prompt training as a prerequisite, not a standalone course. Prompt writing skills unlock everything else in the AI maturity curriculum. Without them, more advanced training (multi-agent orchestration, context engineering, agent supervision) builds on a shaky foundation. The training curriculum should be: Level 1 (4 hours) - task decomposition and basic prompt structure; Level 2 (4 hours) - context provision and team-specific patterns; Level 3 (2 hours) - prompt debugging and iterative refinement. All three levels should be mandatory for any developer moving from L1 to L2 in the maturity model. Sarah should create an assessment rubric so developers and managers can evaluate prompt skill level consistently.

What Sarah should do - role-specific action plan

VictorStaff Engineer - AI Champion

Victor is the best prompt writer on the team - his AI-assisted tasks consistently produce better results than his colleagues, and he's been asked informally to help others improve. He's been doing this ad-hoc, one conversation at a time, which is not scaling.

What Victor should do: Victor should convert his implicit prompt knowledge into explicit, teachable form. He should pick five recent tasks where his prompts produced significantly better-than-average results and write up what he did: the specific context he provided, the way he scoped the task, the success criteria he specified. These five examples become the core of the team's prompt training material. Victor should also ask for one hour per week to run informal "prompt reviews" where team members bring their most recent AI tasks and Victor helps them identify what made the prompt work or not work. This is a mentorship model that scales Victor's knowledge without requiring a formal training program.

What Victor should do - role-specific action plan