Hey, Gregor here 👋 This is a free edition of the Engineering Leadership newsletter. Every week, I share 2 articles → Wednesday’s paid edition and Sunday’s free edition, with a goal to make you a great engineering leader!
How 18 Top Companies Measure AI’s Impact on Engineering
Written by Laura Tacho, CTO at DX, this new industry report explores how 18 engineering organizations—including Dropbox, Microsoft, GitHub, Atlassian, Adyen, Booking.com, and Grammarly—are measuring AI’s impact on software development.
Today, we are diving deeper into how we can extend this Prompt Framework with Context Engineering → to use it even for more complex tasks like planning engineering projects.
I am happy to bring back Steven Levey as a guest author. If you haven’t yet seen our first collaboration, I definitely recommend checking it out:
Let’s reintroduce our guest author for today’s article and get started!
Reintroducing Steven Levey
Steven Levey is Founder and CEO at Revtelligent, with over 15 years of experience leading innovation across startups and large enterprises.
He’s built and scaled multiple tech companies from the ground up and led transformative AI initiatives at public companies like SailPoint.
Today, Steven specializes in helping organizations move from AI theory to real-world impact → translating hype into measurable business outcomes.
At Revtelligent, he’s focused on helping engineers and leaders to become indispensable AI authorities within their companies.
Prompt Engineering vs Context Engineering
Before we get started, it’s really important to understand the difference.
Context Engineering has become a really important topic in 2025, and the whole idea of it is to create:
The most accurate prompt to get the best results
Provide the best context possible and ideally build it up dynamically
Here is a great comparison between Prompt Engineering and Context Engineering:
Credit for the image: anthropic.com
I haven’t yet seen a lot of practical examples on HOW to actually “engineer your prompts and context”. So, in today’s article, we are doing a step-by-step guide on how you can dynamically create your context and use it in a complex prompt.
And to make it double useful → We are building a prompt that is going to help you with planning your engineering projects. You can adjust it to your needs and start using it immediately.
Let's hand it over to Steven and get started!
Engineering Your Context
Once you have a prompt design that works for you, then the next step is to start building up your repository of prompt templates that you call on to speed up your workflow.
You have some choices:
Build these manually every time.
Build these “Dynamically” (Engineer them)
For building up context, you can also use a number of different things (depending on what tool you use the most) before issuing an instruction to an LLM or asking a question:
These high-level abstractions really just exist to help you manage your context a lot better. Some tools also help with taking actions, but most of it is about context building if you look under the hood.
If you want to achieve the art of the possible, start seeing your Prompts and Context as engineered “code” and “process” that can be engineered and deployed just like any other system.
See your prompt as a template that you can dynamically build up by making API calls, database calls, documentation calls, etc. And it can exist on its own, or it can be placed “in-line”, in an existing workflow or data pipeline.
So, how to start?
Step-by-Step Guide on How to Use Context Engineering to Help With Planning Engineering Projects
Let’s assume you are an Engineering Manager and you are leading 3 teams:
Frontend team,
Backend team, and
DevOps team.
The Product Manager is great, but there is unfortunately a lack of PMs across the company, and the Product Manager is drowning in work, leading multiple projects → planning and prioritizing work for all 3 teams.
To help them with this, we are going to be building a system that will analyse all the work that needs to be done and provide useful suggestions on prioritization, optimization, and overall planning of the project.
Goal:
We will be running the analysis every week on Monday at 8 AM and then sending the results via email or Slack.
Here is a step-by-step plan on what we’ll be doing:
Step 1: Create your ideal prompt → Manually create the prompt with ALL the context you need, to reliably achieve the result you are looking for.
Step 2: Create a working template → When you have a working prompt, then turn that into a “Template” that can be used over and over.
Step 3: Fetch data from source systems → Fill in your Context with dynamic data from your source systems (Jira, Linear, Notion, GitHub, Gitlab, etc.)
We’ll work through an example below to illustrate the point.
Step 1: Create Your Ideal Prompt
Write the ideal “output” example (with the PM providing the example they would love).
Then reverse engineer that output into the “inputs” you’d need as a human to be able to produce that output consistently. Example: You’d need to know the current workload of the team; you need any urgent customer tickets from Jira; what’s in the sprint backlog, etc.
Once you have the “raw data” inputs required, you should add those to the prompt context. Add this into the <context> section of the prompt specifically.
Add your ideal output into the <examples> section of the prompt.
Add the instruction/question into the <action> section of the prompt and then run it!
What does the output look like? Layer in more context by adding in the <role>, <format>, and other sections until you get the output you want and you are happy with.
Take a look at an example completed prompt with all its context filled in. Copy and run this in your AI chat tool of choice. Then move on to Step 2.
<context>
You are working at TechCorp, a software development company currently managing multiple concurrent projects in Q3 2025. The company is operating under specific constraints including a hiring freeze until Q4 2025, a $2.3M budget allocation for Q3-Q4 development, and critical business deadlines.
Current business context includes:
- Customer Portal v2.0 must launch before competitor’s product announcement (estimated August 20th)
- New GDPR requirements must be implemented by September 1st
- 15% of capacity should be allocated to technical debt reduction
- Recent performance shows velocity fluctuations and some team satisfaction concerns
The company has established teams across frontend, backend, and devops with varying availability and skill sets. There are active sprint commitments, resource allocation challenges, and stakeholder concerns about project timelines and risk levels.
## Current Team Structure
```json
{
“teams”: {
“frontend”: {
“lead”: “Sarah Chen”,
“members”: [
{
“name”: “Mike Rodriguez”,
“seniority”: “senior”,
“availability”: 0.8,
“skills”: [”React”, “TypeScript”, “CSS”]
},
{
“name”: “Emma Wilson”,
“seniority”: “mid”,
“availability”: 1.0,
“skills”: [”Vue.js”, “JavaScript”, “UX”]
},
{
“name”: “Alex Kumar”,
“seniority”: “junior”,
“availability”: 1.0,
“skills”: [”HTML”, “CSS”, “JavaScript”]
}
]
},
“backend”: {
“lead”: “David Park”,
“members”: [
{
“name”: “Lisa Thompson”,
“seniority”: “senior”,
“availability”: 0.6,
“skills”: [”Python”, “Django”, “PostgreSQL”]
},
{
“name”: “James Miller”,
“seniority”: “mid”,
“availability”: 1.0,
“skills”: [”Node.js”, “Express”, “MongoDB”]
},
{
“name”: “Rachel Green”,
“seniority”: “senior”,
“availability”: 0.9,
“skills”: [”Java”, “Spring”, “MySQL”]
}
]
},
“devops”: {
“lead”: “Tom Anderson”,
“members”: [
{
“name”: “Kevin Zhang”,
“seniority”: “senior”,
“availability”: 0.7,
“skills”: [”Docker”, “Kubernetes”, “AWS”]
},
{
“name”: “Maria Santos”,
“seniority”: “mid”,
“availability”: 1.0,
“skills”: [”CI/CD”, “Jenkins”, “Azure”]
}
]
}
}
}
```
## Current Sprint Backlog (JIRA Data)
```json
{
“sprint”: {
“id”: “SPRINT-2025-07”,
“name”: “Q3 Feature Development Sprint”,
“startDate”: “2025-07-01”,
“endDate”: “2025-07-14”,
“status”: “active”
},
“tickets”: [
{
“key”: “PROJ-1234”,
“summary”: “Implement user authentication microservice”,
“description”: “Create OAuth2-based authentication service with JWT tokens, rate limiting, and audit logging”,
“priority”: “High”,
“status”: “In Progress”,
“assignee”: “Lisa Thompson”,
“reporter”: “David Park”,
“storyPoints”: 13,
“timeSpent”: “18h”,
“timeRemaining”: “22h”,
“labels”: [”backend”, “security”, “microservice”],
“components”: [”Authentication”, “API Gateway”],
“created”: “2025-06-28T09:00:00Z”,
“updated”: “2025-07-07T14:30:00Z”
},
{
“key”: “PROJ-1235”,
“summary”: “Redesign dashboard UI components”,
“description”: “Update dashboard with new design system, implement responsive layout, and add dark mode support”,
“priority”: “Medium”,
“status”: “To Do”,
“assignee”: “Emma Wilson”,
“reporter”: “Sarah Chen”,
“storyPoints”: 8,
“timeSpent”: “0h”,
“timeRemaining”: “32h”,
“labels”: [”frontend”, “ui”, “design-system”],
“components”: [”Dashboard”, “UI Components”],
“created”: “2025-06-29T11:15:00Z”,
“updated”: “2025-07-05T16:45:00Z”
},
{
“key”: “PROJ-1236”,
“summary”: “Set up production monitoring and alerting”,
“description”: “Configure Prometheus, Grafana, and PagerDuty integration for comprehensive system monitoring”,
“priority”: “High”,
“status”: “Blocked”,
“assignee”: “Kevin Zhang”,
“reporter”: “Tom Anderson”,
“storyPoints”: 5,
“timeSpent”: “8h”,
“timeRemaining”: “12h”,
“labels”: [”devops”, “monitoring”, “infrastructure”],
“components”: [”Monitoring”, “Infrastructure”],
“created”: “2025-06-30T08:30:00Z”,
“updated”: “2025-07-06T10:20:00Z”,
“blockedReason”: “Waiting for AWS permissions approval”
},
{
“key”: “PROJ-1237”,
“summary”: “Optimize database queries for user analytics”,
“description”: “Identify and resolve slow queries in analytics module, implement proper indexing strategy”,
“priority”: “Medium”,
“status”: “Code Review”,
“assignee”: “Rachel Green”,
“reporter”: “David Park”,
“storyPoints”: 3,
“timeSpent”: “12h”,
“timeRemaining”: “4h”,
“labels”: [”backend”, “performance”, “database”],
“components”: [”Analytics”, “Database”],
“created”: “2025-07-01T13:00:00Z”,
“updated”: “2025-07-07T09:15:00Z”
}
]
}
```
## Resource Allocation Matrix
```json
{
“currentQuarter”: “Q3-2025”,
“allocations”: [
{
“project”: “Customer Portal v2.0”,
“deadline”: “2025-08-15”,
“priority”: “P0”,
“resourcesAllocated”: {
“frontend”: 2.5,
“backend”: 1.8,
“devops”: 0.7
},
“budgetUsed”: 0.65,
“riskLevel”: “medium”
},
{
“project”: “Internal Analytics Platform”,
“deadline”: “2025-09-30”,
“priority”: “P1”,
“resourcesAllocated”: {
“frontend”: 1.0,
“backend”: 1.9,
“devops”: 1.0
},
“budgetUsed”: 0.45,
“riskLevel”: “low”
},
{
“project”: “Mobile App MVP”,
“deadline”: “2025-10-15”,
“priority”: “P2”,
“resourcesAllocated”: {
“frontend”: 1.8,
“backend”: 0.6,
“devops”: 0.3
},
“budgetUsed”: 0.25,
“riskLevel”: “high”
}
]
}
```
## Historical Performance Metrics
```json
{
“lastThreeMonths”: {
“velocityTrend”: [
{ “month”: “April”, “storyPointsCompleted”: 89, “sprintGoalsMet”: 0.85 },
{ “month”: “May”, “storyPointsCompleted”: 76, “sprintGoalsMet”: 0.7 },
{ “month”: “June”, “storyPointsCompleted”: 92, “sprintGoalsMet”: 0.9 }
],
“bugEscapeRate”: 0.12,
“averageLeadTime”: “8.5 days”,
“deploymentFrequency”: “2.3 per week”,
“teamSatisfactionScore”: 7.2
}
}
```
## Constraints and Business Context
- **Budget**: $2.3M allocated for Q3-Q4 development
- **Hiring freeze**: No new hires until Q4 2025
- **Key deadline**: Customer Portal v2.0 must launch before competitor’s product announcement (estimated August 20th)
- **Technical debt**: 15% of capacity should be allocated to technical debt reduction
- **Compliance**: New GDPR requirements must be implemented by September 1st
## Recent Stakeholder Feedback
> “The authentication system delays are causing downstream impacts on the customer portal timeline. We need to understand if we can reallocate resources or if we need to adjust scope.” - Jane Smith, Product Owner
> “The mobile app project seems to be falling behind. Given the high risk level, should we consider bringing in external contractors?” - Robert Johnson, Engineering Director
> “Our monitoring gaps are a significant concern. The blocked DevOps ticket needs immediate attention.” - Patricia Lee, CTO
</context>
<role>
You are a senior project manager and resource planning specialist at TechCorp with access to current project data, team information, and resource allocation details. You work for Steven, a Product Manager responsible for overseeing multiple software projects. Your expertise includes analyzing project status, resource optimization, risk assessment, and timeline management. You should demonstrate deep knowledge of agile methodologies, team dynamics, and strategic business planning.
</role>
<action>
Given the current project status, team availability, resource constraints, and business priorities, analyze the provided data and provide strategic recommendations including:
1. **Immediate Action Items**: Identify the top 3 actions that need to be taken this week to address the most critical issues
2. **Resource Reallocation Recommendations**: Propose how to redistribute team members across projects to optimize delivery timelines while maintaining quality
3. **Risk Mitigation Strategy**: Develop specific steps to address the high-risk Mobile App MVP project and the blocked monitoring ticket
4. **Timeline Adjustments**: Recommend realistic timeline adjustments for each project based on current velocity trends and constraints
5. **Communication Plan**: Define key messages for stakeholders and present trade-offs involved in your recommendations
Base your analysis on the team structure, sprint backlog, resource allocation matrix, historical performance metrics, and stakeholder feedback provided.
</action>
<format>
Structure your response with clear headings for each of the 5 required sections. Use bullet points for action items and recommendations. Include specific timelines where applicable. Present resource allocation recommendations in a clear, tabular format when possible. Provide reasoning for each major recommendation. Keep the response comprehensive but concise, focusing on actionable insights rather than restating the provided data.
</format>
<tone>
Communicate with the authority and expertise of a senior project manager. Use professional, analytical language appropriate for executive-level stakeholders. Be direct about challenges and realistic about constraints while maintaining a solutions-focused approach. Balance optimism with pragmatic assessment of risks and trade-offs.
</tone>
<examples>
**Example Resource Reallocation:**
- Move Mike Rodriguez (0.8 availability, React/TypeScript) from Mobile App to Customer Portal frontend to accelerate critical deadline
- Reassign Maria Santos (full availability, CI/CD expertise) to unblock monitoring ticket by coordinating AWS permissions
**Example Risk Mitigation:**
- For blocked DevOps ticket: “Escalate AWS permissions request to Patricia Lee (CTO) for executive intervention, establish daily check-ins with Tom Anderson until resolved”
- For high-risk Mobile App: “Recommend scope reduction to core MVP features, consider external contractor for specialized mobile development skills”
**Example Communication Message:**
“Based on current velocity trends and resource constraints, we recommend prioritizing Customer Portal v2.0 delivery while accepting a 3-week delay on Mobile App MVP to ensure quality and meet the critical August 15th deadline.”
</examples>
<definition_of_done>
Your response must:
- Address all 5 required sections with specific, actionable recommendations
- Base recommendations on the provided data (team structure, current sprint, performance metrics)
- Include clear reasoning for major decisions
- Respect the constraints (hiring freeze, budget limits, technical debt allocation)
- Provide realistic timelines that account for current team velocity
- Consider stakeholder concerns and business priorities
- Be implementable within the current organizational structure and capabilities
- Include specific names and assignments where appropriate based on team member skills and availability
</definition_of_done>
Step 2: Create a Working Template
Now that you have a working example that you’re happy with, you need to replace the hard-coded sections of the prompt with placeholders that you will dynamically fill in through your AI Workflow, which we’ll get to.
You’ll want to choose a templating language like Jinja (for Python) or an equivalent in your preferred language. You just need the ability to replace values and ideally loop through data with conditional logic capabilities.
Below is an example of how I would use Jinja’s double curly brace syntax to replace the key parts of the prompt and prepare it as a template, ready to have data dynamically inserted. (Notice the data loops that are useful to build up context)
The Template With Variable Placeholders
<context>
You are working at {{company_name}}, a software development company currently managing multiple concurrent projects in {{current_quarter}}. The company is operating under specific constraints including {{hiring_constraint}}, {{budget_allocation}}, and critical business deadlines.
Current business context includes:
{% for deadline in critical_deadlines -%}
- {{deadline.description}} ({{deadline.date}})
{% endfor -%}
- {{technical_debt_allocation}} of capacity should be allocated to technical debt reduction
- Recent performance shows {{performance_summary}}
The company has established teams across {{team_types}} with varying availability and skill sets. There are active sprint commitments, resource allocation challenges, and stakeholder concerns about project timelines and risk levels.
## Current Team Structure
```json
{{team_structure|tojson}}
```
## Current Sprint Backlog (JIRA Data)
```json
{
“sprint”: {
“id”: “{{sprint_id}}”,
“name”: “{{sprint_name}}”,
“startDate”: “{{sprint_start_date}}”,
“endDate”: “{{sprint_end_date}}”,
“status”: “{{sprint_status}}”
},
“tickets”: [
{% for ticket in sprint_tickets -%}
{
“key”: “{{ticket.key}}”,
“summary”: “{{ticket.summary}}”,
“description”: “{{ticket.description}}”,
“priority”: “{{ticket.priority}}”,
“status”: “{{ticket.status}}”,
“assignee”: “{{ticket.assignee}}”,
“reporter”: “{{ticket.reporter}}”,
“storyPoints”: {{ticket.story_points}},
“timeSpent”: “{{ticket.time_spent}}”,
“timeRemaining”: “{{ticket.time_remaining}}”,
“labels”: {{ticket.labels}},
“components”: {{ticket.components}},
“created”: “{{ticket.created}}”,
“updated”: “{{ticket.updated}}”{% if ticket.blocked_reason %},
“blockedReason”: “{{ticket.blocked_reason}}”{% endif %}
}{% if not loop.last %},{% endif %}
{% endfor %}
]
}
```
## Resource Allocation Matrix
```json
{
“currentQuarter”: “{{current_quarter}}”,
“allocations”: [
{% for allocation in project_allocations -%}
{
“project”: “{{allocation.project}}”,
“deadline”: “{{allocation.deadline}}”,
“priority”: “{{allocation.priority}}”,
“resourcesAllocated”: {
{% for team, count in allocation.resources.items() -%}
“{{team}}”: {{count}}{% if not loop.last %},{% endif %}
{% endfor %}
},
“budgetUsed”: {{allocation.budget_used}},
“riskLevel”: “{{allocation.risk_level}}”
}{% if not loop.last %},{% endif %}
{% endfor %}
]
}
```
## Historical Performance Metrics
```json
{
“lastThreeMonths”: {
“velocityTrend”: [
{% for month in velocity_trend -%}
{ “month”: “{{month.name}}”, “storyPointsCompleted”: {{month.story_points}}, “sprintGoalsMet”: {{month.goals_met}} }{% if not loop.last %},{% endif %}
{% endfor %}
],
“bugEscapeRate”: {{bug_escape_rate}},
“averageLeadTime”: “{{average_lead_time}}”,
“deploymentFrequency”: “{{deployment_frequency}}”,
“teamSatisfactionScore”: {{team_satisfaction_score}}
}
}
```
## Constraints and Business Context
{% for constraint in business_constraints -%}
- **{{constraint.type}}**: {{constraint.description}}
{% endfor %}
## Recent Stakeholder Feedback
{% for feedback in stakeholder_feedback -%}
> “{{feedback.message}}” - {{feedback.author}}, {{feedback.title}}
{% endfor %}
</context>
<role>
You are a {{role_title}} at {{company_name}} with access to current project data, team information, and resource allocation details. You work for {{manager_name}}, a {{manager_title}} responsible for {{manager_responsibilities}}. Your expertise includes {{expertise_areas}}. You should demonstrate deep knowledge of {{knowledge_areas}}.
</role>
<action>
Given the current project status, team availability, resource constraints, and business priorities, analyze the provided data and provide strategic recommendations including:
{% for section in analysis_sections -%}
{{loop.index}}. **{{section.title}}**: {{section.description}}
{% endfor %}
Base your analysis on the team structure, sprint backlog, resource allocation matrix, historical performance metrics, and stakeholder feedback provided.
</action>
<format>
{{response_format_instructions}}
</format>
<tone>
{{communication_tone_guidelines}}
</tone>
<examples>
{% for example in response_examples -%}
**{{example.title}}:**
{{example.content}}
{% endfor %}
</examples>
<definition_of_done>
Your response must:
{% for requirement in completion_requirements -%}
- {{requirement}}
{% endfor %}
</definition_of_done>
Step 3: Fetch Data From Source Systems
Now that you have a template prompt, you need a way to fetch data from source systems, insert it into the Prompt Template, and then send that off to an LLM provider to get a response back.
There are many ways you could do this, but really, all you have to do is put together a script that:
Fetches data from any source system and gets the results back as a JSON object. (Things like current quarter or date etc., can be calculated at runtime)
Pass the data to the template and have Jinja extract all the data from the JSON object and put it into the right places in the template. This returns a completed prompt as text.
Pass the completed prompt through to the LLM and then process the result however you want (email, Slack, etc.)
🎁 GitHub Repository: Planning Your Engineering Projects
To help you with this, you can check out the complete finished project on how to do Context Engineering to create complex prompts with dynamically fetched data. With an example of Planning Your Engineering Projects.
P.S. You can extend this example into various useful cases further.
Conclusion: Prompts as Code
To ensure what you are building is reliable and maintainable, it’s best to treat your prompts and context templates as code.
This approach borrows proven practices from software development, like “infrastructure as code,” and applies them to how you manage your interactions with large language models (LLMs).
Thinking of prompts as code means they should be:
1. Version Controlled
Just like any other piece of software, prompts should be stored in a version control system like Git. This allows you to:
Track every change made to a prompt.
Revert to a previous version if a change degrades performance.
Allow team members to collaborate on prompts by creating PRs.
2. Shareable
When prompts are stored in a central repository, they become reusable assets. A well-designed prompt for a task like ranking priorities can be easily shared and used across different teams or applications, ensuring consistency and saving time.
3. Testable and Evaluative
Managing prompts as code lets you build a set of standardized tests and evaluations. With these tests/evals, you can continuously evaluate your prompts to see how different inputs affect the outputs.
This is especially important when the underlying AI models are updated. By running your test/eval suite against a new model or prompt change, you can:
Objectively measure if the model update improves or harms your results.
Pinpoint which prompts need to be adjusted for the new model.
Make informed decisions about when to adopt new model versions based on data, not guesswork.
By applying the discipline of coding to context engineering, you move from trial-and-error to a structured, reliable process.
Last words
Special thanks to Steven for sharing his insights on this very important topic. And also for creating a whole working example of how you can do context engineering in a real-world use case!
Make sure to check him out on LinkedIn and also check out Revtelligent → he’s doing a lot of great stuff there.
We are not over yet!
How Engineering Teams Set Goals and Measure Performance
You are more than welcome to find whatever interests you here and try it out in your particular case. Let me know how it went! Topics are normally about all things engineering related, leadership, management, developing scalable products, building teams etc.
