Dibe Coding Methodology Agent

[JonasHelming]

🧠 Dibe Coding Process Overview

This process defines a structured yet flexible approach to leveraging AI agents for coding tasks. It helps developers decide when and how to delegate to AI, iteratively improve prompts, and manage task complexity through division and summarization.

---

🔹 1. Start

The process begins with an open decision to consider AI assistance for a given task.

---

🔸 2. Task Suitability Check (Task suitable?)

At this point, a critical evaluation determines if the task is suitable for delegation to an AI coding assistant.

• If No → The process ends with a manual or traditional approach (Do not delegate to AI).
• If Yes → Proceed to externalization decision.

---

🔸 3. Externalize Task? (Externalize Task?)

The next step is to decide whether to externalize the task, i.e., create a task context to explicitly define and describe the problem.

• If Yes → Proceed to Create task context.
• If No → Continue directly to the division decision.

---

🔸 4. Create Task Context

Here, a structured context or problem description is created to inform and guide the AI. This can improve result quality and prompt effectiveness.

---

🔸 5. Divide Task? (Divide?)

Now, evaluate whether the task should be handled as a whole or split into smaller parts.

• If Yes → Go to Divide, which restructures the task into manageable sub-tasks.
• If No → Proceed to the initial prompting step.

---

🔸 6. Prompt

A prompt is crafted and submitted to the AI agent. This is the first interaction with the assistant aimed at generating a meaningful result.

---

🔸 7. Review and Decide (Review and Decide)

The AI’s response is evaluated at a high level, and the next action is chosen:

• Refine:
  If the result is close, continue iteratively in the same session.
  Imagine you review a PR and you are motivated to continue. There might be a few edges missing or some code parts to be optimized, but generally it looks fine already.

• Redo:
  If the task understanding or output is significantly off, revise the prompt and try again.
  Use this option if you have the feeling there was some important information missing, e.g. some implicit requirements, some code examples, or some context information. So basically, you have a good idea how to improve your prompt.

• Divide:
  If the problem is too complex or ill-structured, go back and break it down further.
  Use this option if your prompt gets too complex and you do not know how to improve it. Break the problem down into smaller, manageable steps.

• Summarize:
  If the session is too long or cluttered, summarize the state and start fresh with a condensed input.
  Use this option if you have the feeling you are running in circles, you get unexpected results, or previous instructions are forgotten again. Condense the current state and restart in a fresh session.

Each of these decisions leads back to the prompting phase, continuing the cycle until a satisfying result is achieved.

---

🔁 Iterative Nature

The process is designed to be cyclical and adaptive. Every result loops back to refinement, re-prompting, or restructuring until the solution meets expectations.

Diagram sources

digraph G {
rankdir=TD;
node [shape=box, style=rounded];

Start [label="Start", shape=ellipse];
A [label="Task suitable?", shape=diamond];
C [label="Do not delegate to AI"];
E [label="Externalize Task?", shape=diamond];
F [label="Create task context"];
H [label="Divide?", shape=diamond];
I [label="Prompt"];
J [label="Review and Decide", shape=diamond];
K [label="Refine"];
L [label="Redo"];
M [label="Divide"];
N [label="Summarize"];

Start -> A;
A -> C;
A -> E;
E -> F;
F -> H;
E -> H;
H -> I;
H -> M;
M -> I;
I -> J;
J -> K;
J -> L;
J -> M;
J -> N;
K -> I;
L -> I;
N -> I;

}

[planger]

Thank you, this looks like a great start!

I made a few iterations in a discussion with Claude around the following points:

• Dual-criteria entry point: I think we should clarify already in the process what "suitable" means. To me those are two distinct decisions: AI capability and context. If it is just context (what I would claim is more often the case than capability for software engineering), we have the decision to establish the context -- again with the help of AI -- or drop it because the effort of establishing the context is not worth the task at hand.
• Context discovery loop: To me context discovery is a loop where we may loop until we believe we have enough, then try it, but potentially come back if we observe it doesn't work yet.
• Task complexity assessment before context creation: At least I try to make the decision on task break down before creating the task context, because the context might be written in a different way when I know it is divided into subtasks.
• Pathways from Review and decide: To me it is more like a loop to a specific step above, like I need to divide, I need more context, or I drop it because creating context is too much work, or AI capabilities aren't there.

flowchart TD
    A([Start]) --> B{Is task within\nAI capabilities?}
    B -->|No| C[Do not delegate to AI]
    B -->|Yes| D{Can we externalize\nsufficient context?}
    D -->|No| E[Work with AI to\ndescribe context]
    D -->|No & too much work| C
    E --> D
    D -->|Yes| F{Is task complex\nor multi-stage?}
    F -->|Yes| G[Divide into subtasks]
    G --> H[Create task context]
    F -->|No| H
    H --> I[Prompt AI with task]
    I --> J{Review and decide}
    J -->|Refine or Redo| I
    J -->|Complete| K([End])
    J -->|Divide further| F
    J -->|Need more context| D
    J -->|AI capabilities insufficient| B

    %% Styling
    classDef decision fill:#f9f,stroke:#333,stroke-width:2px;
    classDef process fill:#bbf,stroke:#333,stroke-width:2px;
    classDef terminal fill:#dfd,stroke:#333,stroke-width:2px;
    
    class B,D,F,J decision;
    class C,E,G,H,I process;
    class A,K terminal;

Loading

What do you think?