Reusing Templates Across Tasks
Building a personal prompt library with parameterized templates.
Reusing Templates Across Tasks is a free AI Prompt Engineering lesson on CoddyKit — lesson 4 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the AI Prompt Engineering learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.
From Ad Hoc to a Prompt Library
Most prompt engineers start by writing prompts ad hoc — one for each task, saved loosely in a notes app or chat history. This works at small scale but breaks down when you need consistency across tasks, team members, or time.
A prompt library is a structured collection of reusable prompt templates — organized, named, versioned, and documented. Building one is an investment that pays off quickly in any workflow that generates AI content regularly.
File Organization: The Flat Structure
The simplest prompt library is a flat directory of template files:
prompts/ email_cold_outreach.j2 email_follow_up.j2 linkedin_post.j2 product_description.j2 blog_post_intro.j2 support_reply.j2
A flat structure works well up to about 30-50 templates. Beyond that, a categorized directory structure becomes easier to navigate.
File Organization: The Categorized Structure
For larger libraries, organize templates by content type or use case:
prompts/ marketing/ email_cold_outreach.j2 social_linkedin_post.j2 support/ reply_complaint.j2 reply_question.j2 content/ blog_post.j2 product_description.j2 internal/ meeting_summary.j2 project_update.j2
Match the categorization to how your team thinks about tasks, not to prompt engineering concepts.
Naming Conventions
Template names should communicate purpose at a glance. Good naming patterns:
- content_type + context:
email_cold_outreach,post_linkedin_announcement - action + object:
summarize_meeting,analyze_feedback,generate_tagline - role + task:
support_reply_complaint,marketing_product_description
Avoid generic names like template1, prompt_v2, or new_thing. A good name is readable without opening the file.
Versioning Templates
Prompts change over time as you discover improvements. Version control for templates prevents lost history and regression:
- Store templates in git — every change is tracked and reversible
- For file-based versioning without git:
email_cold_outreach_v1.j2,v2.j2,v3.j2 - Tag major production versions: add a comment at the top marking which version went live and when
- Never overwrite without keeping a copy — what worked last month may need to be restored
Git is the most robust option: use a dedicated prompts/ directory in your project repo.
Template Documentation Header
Every template file should have a documentation header. This is a comment block at the top that captures critical metadata:
# Template: email_cold_outreach.j2
# Version: 2.1
# Author: Sarah Chen
# Created: 2025-03-15
# Last modified: 2025-05-10
# Changes in v2.1: Added 'value_prop' variable, removed generic opener
#
# Purpose:
# Generate personalized cold outreach emails for B2B sales.
#
# Required variables:
# - sender_name: str — Name of the sender
# - recipient_name: str — First name of the recipient
# - company_name: str — Recipient's company
# - value_prop: str — 1-2 sentence value proposition tailored to this prospect
# - cta: str — Specific call to action (e.g., '15-minute discovery call')
#
# Optional variables:
# - tone: str (default: 'professional but warm')
# - word_count: int (default: 120)
#
# Example output: see examples/email_cold_outreach_sample.txt
# Known limitations: Performs best when value_prop is specific to the company.A Template Registry
For team environments, a template registry — a central index file listing all available templates — makes discovery much faster:
# prompts/registry.py
# Central index of all prompt templates
TEMPLATE_REGISTRY = {
'email_cold_outreach': {
'file': 'marketing/email_cold_outreach.j2',
'description': 'Cold outreach email for B2B prospecting',
'required_vars': ['sender_name', 'recipient_name', 'company_name', 'value_prop', 'cta'],
'optional_vars': {'tone': 'professional but warm', 'word_count': 120},
'version': '2.1',
'owner': 'sarah.chen'
},
'linkedin_post': {
'file': 'marketing/linkedin_post.j2',
'description': 'LinkedIn announcement post with professional tone',
'required_vars': ['company', 'announcement', 'cta'],
'optional_vars': {'tone': 'professional and approachable', 'word_count': 180},
'version': '1.0',
'owner': 'marketing_team'
}
}
def get_template_info(name):
return TEMPLATE_REGISTRY.get(name, None)Cross-Task Template Reuse
The real power of a library is discovering that the same template works across multiple tasks with minor variable changes. Look for cross-task reuse opportunities:
- A product description template can generate both website copy and app store descriptions with different length and tone variables
- A summary template works for meeting summaries, article summaries, and code review summaries by changing the content type variable
- A comparison template works for products, job candidates, and technical approaches by changing subject and criteria variables
When you find yourself writing a new template, search the library first.
Template Composition: Base + Child
Jinja2 supports template inheritance — a base template defines a common structure, and child templates override specific blocks. This reduces duplication across related templates:
# prompts/base_content.j2 — shared structure for all content templates
'''
You are a professional writer for {{company}}.
Style rules (apply to all outputs):
- Active voice
- No jargon unless defined
- Sentences under 25 words
- No passive voice
- Warm, direct tone
{% block task %}{% endblock %}
{% block constraints %}
Length: {{word_count | default(200)}} words.
{% endblock %}
'''
# prompts/blog_post.j2 — inherits base, adds blog-specific instructions
'''
{% extends 'base_content.j2' %}
{% block task %}
Write a blog post about {{topic}} for {{audience}}.
Structure: Hook (1 para) + Problem (1-2 para) + Solution (2-3 para) + Takeaway (1 para).
Include one concrete example.
{% endblock %}
{% block constraints %}
{{ super() }}
Do not mention competitors. Include one pull quote.
{% endblock %}
'''Tracking Template Performance
In production pipelines, track which template versions produce the best outputs. A simple logging approach:
import json
import datetime
def log_generation(template_name, template_version, variables, output, rating=None):
log_entry = {
'timestamp': datetime.datetime.utcnow().isoformat(),
'template': template_name,
'version': template_version,
'input_vars': {k: str(v)[:50] for k, v in variables.items()}, # truncate for log
'output_length': len(output),
'rating': rating # optional human rating 1-5
}
with open('logs/generation_log.jsonl', 'a') as f:
f.write(json.dumps(log_entry) + '\n')
# Usage after generation
log_generation(
template_name='email_cold_outreach',
template_version='2.1',
variables={'sender_name': 'Alice', 'company_name': 'Acme'},
output='Dear Mr. Smith...',
rating=4
)When to Retire a Template
Templates become outdated. Signs a template should be retired or updated:
- Outputs consistently require heavy manual editing — the template is not capturing the right requirements
- The task has changed (new brand guidelines, new audience, new format requirements)
- The model version changed and the template instructions no longer work as expected
- A better template was written that supersedes this one
Archive rather than delete retired templates — mark them as deprecated in the registry and keep the files in an archive/ subdirectory. You may need to understand why old outputs looked the way they did.
Knowledge Check: Prompt Libraries
Your team of 8 people generates AI content for three different use cases: email campaigns, product documentation, and social media. You currently have 45 prompt templates saved in a shared Google Doc, with no consistent naming, no version history, and no documentation. Which is the highest-impact first improvement to make?
Recap: Reusing Templates Across Tasks
A prompt library transforms ad hoc prompts into a reusable, maintainable asset. The key practices are: organized file structure (flat up to 50 templates, categorized beyond), consistent naming conventions, documentation headers with required variables and version notes, and git for version control.
The highest-value library behavior is cross-task reuse: the same template structure serving multiple use cases by changing variable values. Template composition via Jinja2 inheritance reduces duplication for related templates. Track performance and retire outdated templates actively.
Frequently asked questions
Is the “Reusing Templates Across Tasks” lesson free?
Yes — the full text of “Reusing Templates Across Tasks” is free to read here on the web, and the AI Prompt Engineering course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the AI Prompt Engineering course, upgrade to CoddyKit PRO.
What will I learn in “Reusing Templates Across Tasks”?
Building a personal prompt library with parameterized templates. You practise AI Prompt Engineering with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.
Do I need any experience to start AI Prompt Engineering?
No prior experience is required. AI Prompt Engineering on CoddyKit is structured for beginners through advanced learners; this is — lesson 4 of 4, so you can start here or from the beginning and move at your own pace.
How long does the “Reusing Templates Across Tasks” lesson take?
Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.
Can I write and run code in this AI Prompt Engineering lesson?
Yes. Every AI Prompt Engineering lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.
All lessons in this course
- What Is a Prompt Template?
- Creating Fill-in-the-Blank Patterns
- Variable Substitution Techniques
- Reusing Templates Across Tasks