{"id":21988,"date":"2025-09-04T14:55:10","date_gmt":"2025-09-04T13:55:10","guid":{"rendered":"https:\/\/www.equalexperts.com\/?p=21988"},"modified":"2025-09-05T00:54:19","modified_gmt":"2025-09-04T23:54:19","slug":"from-madness-to-method-with-ai-coding-part-1-meta-prompting","status":"publish","type":"post","link":"https:\/\/www.equalexperts.com\/blog\/ai\/from-madness-to-method-with-ai-coding-part-1-meta-prompting\/","title":{"rendered":"From madness to method with AI coding: Part 1 – Meta-prompting"},"content":{"rendered":"

Our team at Equal Experts is always keen to explore the potential of new technologies – provided they create genuine business value for our customers. Organisations in our network know that generative AI can be applied to software development, but we\u2019re increasingly noticing that people are frustrated and disappointed with the results they\u2019re getting when coding with an AI assistant. They tell us how they end up in the infamous AI \u201cdoom loop\u201d whilst wrestling to keep the LLM on track, and wonder: <\/span>is AI-assisted coding really worth it?<\/b>\u00a0<\/span><\/p>\n

We\u2019ve experienced the same frustrations, but we knew there had to be a way to help AI do a better job. Our industry has spent decades developing standard practices rooted in a rigorous engineering mindset, so we wanted to intentionally apply more method to the use of AI in coding. This blog is the first in a five-part series about what we\u2019ve learned about how to make AI a true accelerator for software development.<\/span><\/p>\n

From madness to method: Part 1 – meta-prompting as an engineering method<\/span><\/h2>\n

So, you\u2019ve experimented with AI-assisted coding and it wasn\u2019t the fix-all solution you thought it might be. At this point, you need to take a step back and develop a unified approach that yields the highest quality results; code that should be virtually indistinguishable from your own best work. Here\u2019s a step-by-step guide:<\/span><\/p>\n

1. Establish a prompt template<\/strong><\/h3>\n

Meta-prompting is the foundation of the approach we use; it\u2019s the building block for everything else we will cover in this blog series. Everything begins with a prompt, so we start by <\/span>instructing an LLM to generate its own prompt<\/b>. We provide the LLM with guidelines regarding the general structure of the prompt and offer an example of what a good prompt looks like, using a prompt template. Here is an example of a template we\u2019ve used on a pilot project with one of our customers:<\/span><\/p>\n

# [Feature\/System Name]\r\n\r\n*Write a brief paragraph describing the high-level purpose and context. What problem does this solve?\r\nWhat is the main objective? Keep this concise and focused on the \"why\" rather than the \"how\".*\r\n\r\n## Requirements\r\n\r\n*List the specific, measurable acceptance criteria that define when this feature is complete. These\r\nshould be testable and unambiguous. Think of these as your definition of done.*\r\n\r\n- Requirement 1\r\n- Requirement 2\r\n- Requirement 3\r\n\r\n## Rules\r\n\r\n*Specify any rules files that should be included when working on this feature. This includes any\r\nrules files that might be relevant for this slice to be implemented. The rules files are usually\r\nfound under the `rules\/` directory of this project.*\r\n\r\n- rules\/my-rules-1.md\r\n- rules\/my-rules-2.md\r\n- rules\/my-rules-3.md\r\n\r\n## Domain\r\n\r\n*If applicable, describe the core domain model using pseudo-code in a modern language like\r\nTypeScript or Kotlin. Focus on the key entities, relationships, and business logic. This\r\nsection helps establish the mental model for the feature.*\r\n\r\n\/\/ Core domain representation in markdown block\r\n\r\n## Testing Considerations\r\n\r\n*Describe how you want this feature to be tested. What types of tests are needed? What\r\nscenarios should be covered? What are the quality gates?*\r\n\r\n*Examples: unit test coverage requirements, integration testing adapters, acceptance\r\ntesting a workflow, performance benchmarks, etc.*\r\n\r\n## Implementation Notes\r\n\r\n*Document your preferences for how this should be built. This might include architectural\r\npatterns, coding standards, technology choices, or specific approaches you want followed.*\r\n\r\n*Examples: preferred design patterns, coding style, performance requirements, technology\r\nconstraints*\r\n\r\n## Specification by Example\r\n\r\n*Provide concrete examples of what the feature should do. This could be API request\/response\r\nexamples, Gherkin scenarios, sample CSV representation, or user interaction flows. Make the\r\nabstract requirements tangible.*\r\n\r\n*Examples: Gherkin scenarios, JSON payload, UI mockups, CSV samples*\r\n\r\n## Extra Considerations\r\n\r\n*List important factors that need special attention during implementation. This often grows\r\nas you discover edge cases or constraints during development. Think about non-functional\r\nrequirements, constraints, or gotchas.*\r\n\r\n- Consideration 1\r\n- Consideration 2\r\n- Consideration 3\r\n\r\n## Verification\r\n\r\n*Create a checklist to verify that the feature is complete and working correctly. These\r\nshould be actionable items that can be checked off systematically.*\r\n\r\n- [ ] Verification item 1\r\n- [ ] Verification item 2\r\n- [ ] Verification item 3\r\n\r\n---\r\n\r\n<\/pre>\n
You can save your template in the<\/span> prompts\/<\/strong> directory of your project. This location is also where all your other prompts should live, perhaps sequentially numbered in the order that you introduce them.<\/span><\/p>\n
2. Start meta-prompting<\/strong><\/h3>\n
Now the scene is set for meta-prompting. In our client\u2019s case, we wanted to write code using an AI-assisted approach that <\/span>isolates each interaction<\/b> and treats the LLM as a <\/span>stateless function<\/b> rather than a conversational partner, to minimise random effects. We view the prompt as a detailed imperative for the LLM to build something in a single operation, or a “Oneshot prompt”.<\/span><\/p>\n
We start by opening <\/span>a new chat window<\/b>, where we detail everything we want the LLM to achieve in the next piece of work. Here\u2019s an example:<\/span><\/p>\n
Please generate a prompt that instructs an LLM to perform the following tasks:\r\n\r\n* Implement a Supplier API at `\/api\/suppliers`\r\n* Use this API to populate the appropriate supplier ref and name fields on the supplier page (2) \r\n  of the product incident creation workflow.\r\n\r\nThe API should serve an array of suppliers, with each supplier represented by a supplier reference\r\n(text identifier) and a supplier name.\r\n\r\n```\r\n{\r\n    [\r\n        { \"SUP-1234\": \"Supplier 1\" },\r\n        { \"SUP-1235\": \"Supplier 2\" }\r\n    ]\r\n}\r\n```\r\n\r\nFurther, the API should be a mock that returns 10 suppliers with realistic names for product suppliers.\r\n\r\nEnsure that we have acceptance tests for the supplier page that renders the correct data retrieved\r\nfrom our mock API. Ensure that all components on the page have the appropriate unit tests. Ensure\r\nthat you are following our test rules.\r\n\r\nPlease follow the prompt structure closely as detailed in `prompts\/00-prompt-template.md`. Write the\r\nprompt as Markdown and place it under the `prompts` directory as `07-supplier-functionality.md`\r\n\r\n---\r\n<\/pre>\n
In our prompt, we include a reference to our template, then run it. The <\/span>resulting prompt<\/span><\/a> explains how the LLM should implement the feature in a single operation – faster and with greater accuracy than it would otherwise achieve.\u00a0<\/span><\/p>\n
5 basic rules for effective Meta-prompting<\/span><\/h2>\n
To get the best results with AI-assisted coding:\u00a0<\/span><\/p>\n
    \n
  1. Start fresh<\/span> \u2013 always open a new chat so the AI has no prior context.<\/span><\/li>\n
  2. Provide a meta-prompt template<\/span> \u2013 a structured guide for what a \u201cgood prompt\u201d looks like (we keep ours in a project directory, versioned alongside code).<\/span><\/li>\n
  3. Write your \u201crambly\u201d request<\/span> \u2013 in plain words (with plenty of detail and context), explain what you want the AI to build.<\/span><\/li>\n
  4. Ask the AI to rewrite it<\/span> \u2013 the model produces its own precise prompt based on the template.<\/span><\/li>\n
  5. Run the generated prompt<\/span> \u2013 the AI then produces the code in one clean pass.<\/span><\/li>\n<\/ol>\n
    Conclusion<\/span><\/h2>\n
    The effect is powerful: given the right context, the AI is better at writing prompts than we are. By applying engineering discipline to prompt design, we reduce randomness, eliminate conversational drift, and get closer to production-quality code quicker. We also reduce frustration for engineering teams, and put an end to the uncertainty about whether AI is a net benefit or a distraction.<\/span><\/p>\n
    Meta-prompting is just one building block in a broader framework we\u2019re developing at Equal Experts. We\u2019ll be sharing more of this method in upcoming posts. If you\u2019d like to explore how this methodology could transform software delivery in your organisation, get in touch.\u00a0<\/span><\/p>\n
     <\/p>\n
    Theory is good, but practice is better. Here\u2019s a quick demo showing meta-prompting applied in real coding:<\/strong><\/p>\n