From fda3c9c02dad897a9ef66291c38ec4e2aa9a3d1e Mon Sep 17 00:00:00 2001 From: robbond Date: Wed, 5 Aug 2026 19:34:57 +0100 Subject: [PATCH] docs: principles and story docs --- ...1_Confidence_Engine_Founding_Principles.md | 24 ++++++++++++++ docs/02_Confidence_Engine_Product_Story.md | 31 ++++++++++++++++++ docs/03_Confidence_Engine_Language_Guide.md | 27 ++++++++++++++++ docs/04_Rob_Thinking_Model.md | 32 +++++++++++++++++++ 4 files changed, 114 insertions(+) create mode 100644 docs/01_Confidence_Engine_Founding_Principles.md create mode 100644 docs/02_Confidence_Engine_Product_Story.md create mode 100644 docs/03_Confidence_Engine_Language_Guide.md create mode 100644 docs/04_Rob_Thinking_Model.md diff --git a/docs/01_Confidence_Engine_Founding_Principles.md b/docs/01_Confidence_Engine_Founding_Principles.md new file mode 100644 index 0000000..226a54f --- /dev/null +++ b/docs/01_Confidence_Engine_Founding_Principles.md @@ -0,0 +1,24 @@ +# Confidence Engine — Founding Principles + +> **Bring us the mess. We will help you find the next understandable step together.** + +## Why this document exists + +The Confidence Engine began as an attempt to capture a repeatable way of thinking: break complicated situations into small pieces, admit what is not yet known, and keep moving until the next useful action becomes clear. + +## Principles + +1. **The engine owns the complexity.** The user should only have to deal with the next manageable step. +2. **Nothing is difficult when it is broken down enough.** If something still feels overwhelming, it has not yet been broken into small enough pieces. +3. **Confidence means knowing the next step.** The next step may be an answer, a person to ask, a place to look or a test to run. +4. **The hardest step should be the first one.** Every following step should feel smaller and more achievable. +5. **Honest uncertainty builds trust.** The engine should never pretend to understand more than it does. +6. **Intelligence should make things easier to understand.** Never make the user feel stupid to make the engine look clever. +7. **The engine guides; it does not judge.** The user should feel accompanied, not examined. +8. **Progress matters more than performance.** Genuine movement beats impressive-sounding output. +9. **Experiments beat opinions.** When we do not know, build the smallest thing that can teach us. +10. **The product should help people earn confidence.** It does not sell certainty; it helps build justified confidence step by step. + +## Test for every decision + +> Does this make the next step clearer, smaller, more honest or more achievable for the user? diff --git a/docs/02_Confidence_Engine_Product_Story.md b/docs/02_Confidence_Engine_Product_Story.md new file mode 100644 index 0000000..1fcd76c --- /dev/null +++ b/docs/02_Confidence_Engine_Product_Story.md @@ -0,0 +1,31 @@ +# Confidence Engine — Product Story + +> **The Confidence Engine helps people take the next small step when a problem feels too big to know where to start.** + +## The problem + +The blank page is hard because there are too many possible first moves. Most tools ask the user to organise the problem before they can begin. + +## The idea + +Start with whatever the person can give: a question, observation, concern or messy description. From then on, the engine makes each next step smaller. + +## How it works + +1. Start with the mess. +2. Find the next useful uncertainty. +3. Ask for something achievable. +4. Remember and reorganise what has been learned. +5. Build justified confidence until the person knows what to do next. + +## What makes it different + +It does not simply try to answer. It guides the user from uncertainty to understood next actions, while being honest about what is and is not known. + +## Commercial value + +RDB Solutions is not selling an LLM or prompt wrapper. It is developing a repeatable method for turning uncertainty into understood next steps, suitable for subscriptions, teams, APIs, domain-specific products and facilitated services. + +## Short pitch + +> When you do not know where to start, the Confidence Engine helps you find the next small step — then keeps making the next step clear until you are confident enough to act. diff --git a/docs/03_Confidence_Engine_Language_Guide.md b/docs/03_Confidence_Engine_Language_Guide.md new file mode 100644 index 0000000..06b82fb --- /dev/null +++ b/docs/03_Confidence_Engine_Language_Guide.md @@ -0,0 +1,27 @@ +# Confidence Engine — Language Guide + +> **Never use language to make the engine look clever at the user’s expense.** + +## Voice + +Calm, plain, human, honest, specific, non-judgemental and actionable. + +## Translate system language + +- `TOO_BROAD` → “We are trying to solve several things at once. Let’s separate one first.” +- `Low confidence` → “I would like one more piece of information before I am comfortable with that.” +- `Unknown unresolved` → “We have not established this yet.” +- `Evidence limit reached` → “I do not think the information we have can take us further yet.” +- `Cannot determine` → “I cannot tell from what we have so far.” + +## Question style + +Ask something small enough that the user can answer it, know who to ask, know where to look or know how to test it. + +## Avoid + +Jargon, grand statements, false certainty, repeated scenario text, long preambles and technical labels that hide meaning. + +## Final test + +> Would a capable person with no specialist vocabulary understand what we know, what we do not know, and what they can do next? diff --git a/docs/04_Rob_Thinking_Model.md b/docs/04_Rob_Thinking_Model.md new file mode 100644 index 0000000..1520047 --- /dev/null +++ b/docs/04_Rob_Thinking_Model.md @@ -0,0 +1,32 @@ +# Rob’s Thinking Model + +A working description of the problem-solving habits that inspired the Confidence Engine. + +## Central pattern + +Question the framing, break the situation into smaller parts, find the next thing that can be understood or tested, and keep moving without pretending to know more than the evidence supports. + +## Habits + +- Start with what is actually happening. +- Question the question. +- Break complexity into small pieces. +- Find the origin of the situation. +- Compare action with doing nothing. +- Prefer experiments over debate. +- Keep assumptions visible. +- Look for relationships. +- Own uncertainty. +- Seek the next action, not always the answer. +- Explain so others can use the knowledge. +- Keep momentum. +- Notice when terminology or architecture becomes self-important. +- Stop when enough is known. + +## Practical loop + +Observe → Separate → Shrink → Act → Update → Repeat → Stop. + +## Safeguard against drift + +> Did this emerge from observing how Rob thinks, from observing real users, or from observing the working engine? If not, it may be architecture looking for a reason to exist.