Why Do You Need a Process Workflow?

TL;DR → To identify inefficiencies, develop AI Automations, and scale with confidence.

Every business wants AI-driven efficiency. But hiring an AI developer isn’t enough. Without a clear picture of how your processes actually work, there’s always a gap between domain knowledge and implementation.

I’ve personally worked with law firms handling bankruptcy cases, and I can tell you, many of their processes were so complex that it took a significant amount of effort just to understand how all the dots connected. That experience made it clear: unless processes are mapped in a structured, visual way, even skilled professionals spend too much time figuring out the basics before they can suggest improvements.

A well-designed workflow bridges that gap. It documents each step so anyone, whether a lawyer, an AI developer, or a consultant, can quickly understand your operations and propose meaningful improvements.

How to build it?

The core principle: Break the process into steps. Each step falls into one of two categories:

Actions Steps someone (or the system) takes.
e.g., Filing a form or sending a notice.

Decision points Yes/no or multi-option choices driven by rules.
e.g., Is the debtor eligible under Chapter 7?.

The Six Questions to Ask for Every Step

For each step in your workflow, answer the following:

1. What should be the name of the step?

2. Step description

3. What data goes in?

4. Who processes it?

5. What comes out of it?

6. Which tools are used?

Let’s go over these questions one-by-one:

If the step is a decision point, then the question itself that drives the answer should be enough.

And for an action, use the sentence that starts with an action verb, and use present tense & active voice.

For Example: “Download Attachments”, “Validate data”, “Assign task“, “Generate report“

Briefly explain how the input is processed.

Identify the required input:

• Uploaded documents

• API data

• Completed forms

• Automated emails.

• …etc

The responsible person/s for a specific task.

Define the Output. It can be a document, a calculated number, data saving to storage system(Google Drive, Database) etc.

List the systems, platforms, or software required.

Putting It All Together

You’ve seen the individual building blocks, step names, inputs, outputs, ownership, and tools. But what does a complete workflow look like once everything is mapped visually?

Here’s a small real life example of a bankruptcy firm’s noticing system built in FigJam:

This workflow illustrates how a bankruptcy firm’s noticing system operates from start to finish:

• Court notices arrive via structured email.

• An email parsing service classifies and extracts case details.

• A decision point checks for attachments.

• Paralegals process attachments, rename documents, and store them in the correct client or case folders.

• Parsed case data is stored in Google Sheets for easy tracking and auditing.

With a workflow like this, anyone, whether an AI developer, consultant, or even ChatGPT, can follow the bankruptcy noticing process step by step, identify bottlenecks, and propose AI automation opportunities fueling efficiency, growth & scale.

That’s the power of turning complex legal operations into clear, visual workflows.

Hope you enjoyed this guide and found it helpful in thinking about how to map your own processes into clear, visual workflows.

If you’ve ever found yourself wondering, “Is this prompt robust enough for enterprise use?”, you’re not alone. After iterating endlessly, I distilled what works into these 7 essential building blocks.

These components form a repeatable framework that helps reduce hallucinations, ensure consistency, and drive higher-quality outputs, especially when working in regulated, technical, or high-stakes domains.

The 7 Building Blocks of Enterprise-Grade Prompting

1. Role

2. Task

3. Context

4. Instruction

5. Step-by-Step Plan

6. Output Format

7. Examples

We’ll explore each building block using a practical legal analysis example, but the same principles apply across domains, from finance and operations to customer support.

1. Role – Set the Stage

The Role establishes the persona or expertise the model should adopt.

Example

You are a senior legal analyst with 12 years of experience summarizing complex appellate and Supreme Court case law for legal databases and practicing attorneys.

Why it matters

Grounding the model in a role aligns the output with your domain’s tone, accuracy, and assumptions.

Roles can be

• Hyper-specific → “Patent attorney with 15 years of experience”

• General → “Legal Attorney”

2. Task – Define the Goal

Spell out exactly what the model needs to do.

Example

Summarize the attached judicial opinion into a concise, accurate case brief for a legal research database. Highlight key facts, issue(s), holding(s), rationale, and concurring/dissenting opinions.

Why it matters

Vague prompts lead to vague responses. Precision in task definitions directly correlates with output quality.

3. Context – Add Domain-Specific Intelligence

Inject relevant background to ground the model in your environment.

Example

This case was decided by the U.S. Court of Appeals for the Ninth Circuit and involves Fourth Amendment search and seizure claims. It is frequently cited in motions to suppress digital evidence.

Why it matters

Context turns a generic LLM into a domain specialist. It limits hallucinations and makes outputs more situationally aware.

4. Instructions – Set the Boundaries

Define policies, tone, and other dos and don’ts.

Example

- Do not provide legal advice.  
- Do not speculate on alternative holdings.  
- Keep the tone neutral and objective.  
- Use plain legal English, suitable for junior attorneys or paralegals.  
- Include citations as they appear in the original text.  

Why it matters

Instructions reduce risk and help maintain compliance, especially in regulated sectors.

5. Step-by-Step Plan – Guide the Reasoning

Break down the task into discrete steps.

Example

1. Identify Key Facts – Who are the parties? What triggered the legal conflict?  
2. Extract the Legal Issue(s)  
3. Summarize the Holding  
4. Explain the Reasoning  
5. Note Concurring or Dissenting Opinions  
6. Mention Procedural Posture  

Why it matters

This structure supports logical thinking and makes the model’s outputs interpretable and auditable.

6. Output Format – Standardize for Reusability

Tell the model how to format the output.

Example

{
  "case_name_and_citation": "",
  "procedural_posture": "",
  "key_facts": "",
  "issues": "",
  "holdings": "",
  "reasoning": "",
  "concurring_dissenting_opinions": "",
  "significance_or_notes": ""
}

Why it matters

Structured outputs like JSON or tables ensure your LLM responses are machine-parseable and downstream-ready.

7. Examples – Show What “Good” Looks Like

Include reference examples to reduce output variability.

If you’re too lazy to create examples from scratch (like me 😅), ask your domain expert or ChatGPT itself to generate one.

Why it matters

Examples clarify quality expectations and reduce surprises.

Putting It All Together

You don’t always need all 7 blocks at once. A great way to start:

✅ Begin with Task, Context, and Output Format

🔁 Then test and refine

🚀 As complexity increases, add Role, Instructions, and Step-by-Step Plan

Use prompt management tools to make the whole cycle a piece of cake

• Comet Prompt Management

• LangChain

• LangFuse

Meta Prompting: Write Better Prompts with a Prompt

What is Meta-Prompting?

It’s prompting the model to write or improve prompts for you. Think of it as the compiler of prompt engineering.

Why use it?

It’s a shortcut to consistently strong, structured prompts—especially helpful when starting from scratch or creating variants for different departments.

Sample Meta-Prompt

Adapted from OpenAI Docs

You can automate prompt generation using a meta-prompt template and code like this

# improve_prompt.py

from openai import OpenAI

client = OpenAI()

META_PROMPT = """
Given a task description or existing prompt, produce a detailed system prompt to guide a language model in completing the task effectively.

# Guidelines

- Understand the Task: Grasp the main objective, goals, requirements, constraints, and expected output.
- Minimal Changes: If an existing prompt is provided, improve it only if it's simple. For complex prompts, enhance clarity and add missing elements without altering the original structure.
- Reasoning Before Conclusions**: Encourage reasoning steps before any conclusions are reached. ATTENTION! If the user provides examples where the reasoning happens afterward, REVERSE the order! NEVER START EXAMPLES WITH CONCLUSIONS!
    - Reasoning Order: Call out reasoning portions of the prompt and conclusion parts (specific fields by name). For each, determine the ORDER in which this is done, and whether it needs to be reversed.
    - Conclusion, classifications, or results should ALWAYS appear last.
- Examples: Include high-quality examples if helpful, using placeholders [in brackets] for complex elements.
   - What kinds of examples may need to be included, how many, and whether they are complex enough to benefit from placeholders.
- Clarity and Conciseness: Use clear, specific language. Avoid unnecessary instructions or bland statements.
- Formatting: Use markdown features for readability. DO NOT USE ``` CODE BLOCKS UNLESS SPECIFICALLY REQUESTED.
- Preserve User Content: If the input task or prompt includes extensive guidelines or examples, preserve them entirely, or as closely as possible. If they are vague, consider breaking down into sub-steps. Keep any details, guidelines, examples, variables, or placeholders provided by the user.
- Constants: DO include constants in the prompt, as they are not susceptible to prompt injection. Such as guides, rubrics, and examples.
- Output Format: Explicitly the most appropriate output format, in detail. This should include length and syntax (e.g. short sentence, paragraph, JSON, etc.)
    - For tasks outputting well-defined or structured data (classification, JSON, etc.) bias toward outputting a JSON.
    - JSON should never be wrapped in code blocks (```) unless explicitly requested.

The final prompt you output should adhere to the following structure below. Do not include any additional commentary, only output the completed system prompt. SPECIFICALLY, do not include any additional messages at the start or end of the prompt. (e.g. no "---")

[Concise instruction describing the task - this should be the first line in the prompt, no section header]

[Additional details as needed.]

[Optional sections with headings or bullet points for detailed steps.]

# Steps [optional]

[optional: a detailed breakdown of the steps necessary to accomplish the task]

# Output Format

[Specifically call out how the output should be formatted, be it response length, structure e.g. JSON, markdown, etc]

# Examples [optional]

[Optional: 1-3 well-defined examples with placeholders if necessary. Clearly mark where examples start and end, and what the input and output are. User placeholders as necessary.]
[If the examples are shorter than what a realistic example is expected to be, make a reference with () explaining how real examples should be longer / shorter / different. AND USE PLACEHOLDERS! ]

# Notes [optional]

[optional: edge cases, details, and an area to call or repeat out specific important considerations]
""".strip()

def generate_prompt(task_or_prompt: str):
    completion = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": META_PROMPT},
            {"role": "user", "content": "Task, Goal, or Current Prompt:\n" + task_or_prompt},
        ],
    )
    return completion.choices[0].message.content

Must-Read Resources

Official Guides

• OpenAI Text Prompting

• OpenAI Cookbook

• Anthropic Prompt Engineering Guide

Tools & Tutorials

• Anthropic Practical Tutorials

• DSPy

• PromptHub Collections

Final Thoughts

Prompt engineering isn’t just a creative art; it’s the scaffolding for enterprise-grade GenAI systems.

The next time you’re evaluating a prompt, walk through these 7 building blocks. If they’re all in place, your prompt is likely ready for production use.