Datasets:

agentc-consulting
/

aed-conventions

+# 01 · Why Models Need This
+*Excerpted **verbatim** from the author's `naming_conventions.md`, lifted to the
+front of the reading order because it explains why every later rule exists.
+The complete original — with this passage in place — is
+[02_naming_conventions.md](02_naming_conventions.md).*
+---
+Naming conventions are one of the ways that drive the agent enhanced development workflow. The reason for this is that AI models use token windows to understand the context of things.&#x20;
+## Basic Explanation of Tokens & Token Window
+AI models, specifically LLMs, use tokens to represent groups of text. For example the statement:
+`I want to create a new user and assign them to an account.`
+For this example I’ll use Llama 3 to tokenize this prompt. When we tokenize this prompt, it turns into these tokens:
+\`
+```
+'I'
+' want'
+' to'
+' create'
+' a'
+' new'
+' user'
+' and'
+' assign'
+' them'
+' to'
+' an'
+' account'
+'.'
+```
+The extra spaces inside of the single quotes here is to highlight that spaces can be part of a token. Now when the AI model is scanning through the prompt, it’s going to read a group of tokens at a time, shifting down as it processes. For this example I’ll use a 8 token window, shifting 4 tokens at a time so there is some overlap.
+Starting token window `’I want to create a new user and’`
+Next token window `’ a new user and assign them to an’`
+Final token window `‘ assign them to an account.’`
+This window is typically larger than this, but for this example it illustrates how as the window shifts and the LLM model associates groups of tokens. This association is how the relationship of a flow of words is established and influences the direction that the model computes. This is why a naming convention needs to be very consistent.
+---
+*Chapter 01 of the AED canon · continue to
+[02 · Naming Conventions](02_naming_conventions.md) ·
+[reading order](README.md#reading-order)*

02_naming_conventions.md ADDED Viewed

	@@ -0,0 +1,250 @@

+# Naming Conventions Overview for Agent Enhanced Development (AED or AE-dev)
+`_This is a work in progress_`
+Naming conventions are one of the ways that drive the agent enhanced development workflow. The reason for this is that AI models use token windows to understand the context of things.&#x20;
+## Basic Explanation of Tokens & Token Window
+AI models, specifically LLMs, use tokens to represent groups of text. For example the statement:
+`I want to create a new user and assign them to an account.`
+For this example I’ll use Llama 3 to tokenize this prompt. When we tokenize this prompt, it turns into these tokens:
+\`
+```
+'I'
+' want'
+' to'
+' create'
+' a'
+' new'
+' user'
+' and'
+' assign'
+' them'
+' to'
+' an'
+' account'
+'.'
+```
+The extra spaces inside of the single quotes here is to highlight that spaces can be part of a token. Now when the AI model is scanning through the prompt, it’s going to read a group of tokens at a time, shifting down as it processes. For this example I’ll use a 8 token window, shifting 4 tokens at a time so there is some overlap.
+Starting token window `’I want to create a new user and’`
+Next token window `’ a new user and assign them to an’`
+Final token window `‘ assign them to an account.’`
+This window is typically larger than this, but for this example it illustrates how as the window shifts and the LLM model associates groups of tokens. This association is how the relationship of a flow of words is established and influences the direction that the model computes. This is why a naming convention needs to be very consistent.
+## Patterns For Naming Conventions
+For this section I’m going to use the example of implementing the feature story from above:
+\`I want to create a new user and assign them to an account.
+### The Rails Way - Conventions That Have Stood The Test of Time
+The Rails framework has lead the way with “convention over configuration” for well over a decade now. You can really feel the difference this makes in your productivity when getting started. However, once you deviate from the normal Rails conventions you’ll find that Rails can become very painful to work with. This typically happens with non-RESTful business logic being intermingled into what should only be a RESTful end-point.
+The Rails conventions would typically establish the following flow:
+1. Assuming that the `UsersController` already exists, with the standard `create` action inside of it to handle a `POST` request
+2. You (the dev) would update the allowed params to add an `account_id` parameter that would be used to allow the user to be associated to the account.
+This works perfectly for a one-to-one relationship, where one user belongs to one account. What happens if we want to make a many-to-one relationship where the user can have multiple accounts it has access to? This is where the Rails conventions can start to become murky and developers get creative in their solutions.
+You may do one of the following:
+1. You create a service object or PORO to handle the logic from the request and neatly organize the process into 1 or more classes to handle the job.
+2. You update the allowed params to make the `account_id` into an `account_ids` array that manages a join table that represents the association for the user.
+3. You split the association into 2 end-points, and you have your UI perform multiple successive requests in order to create/update all of the relationships.
+4. You stuff a bunch of logic into your controller to determine if/when updates to the joining records need to happen (most common rapid development approach).
+Depending on the maturity of your app, you may start at option 3 and move up in sophistication or simplicity. There’s no real wrong answer here, just a lot of opinions.
+Rails doesn’t have one way of handling increasingly complexity. It’s up to the developer who is writing the start of the feature to hopefully do it in a way that works right for the maturity level of the project at that time.
+However, when we introduce an AI agent into the mix the story begins to change.
+### The Agent Enhanced Way
+Working with an AI agent can be a powerful multiplier for your efficiency as a dev, especially as the app grows in complexity. This is highly dependent on how clear the patterns are that you choose.
+The pattern that you choose is critical because it heavily influences the models train of thought. Since AI models don’t have mental models like you or I do, they become heavily influenced by the way a prompt is written. You can effectively ask the same question, word it in various ways and get the AI to provide a varying answer. This is both good and bad. It means the AI can be articulate with some level of complexity, but it creates less certainty in the consistency required for coding. We can overcome this, mostly, by using a more strict and consistent naming convention.
+Let’s start by looking at something that would generally be acceptable as “good code”.
+```crystal
+class Customer
+  property name : String
+  property email : String
+  def initialize(@name, @email)
+  end
+end
+```
+Here we have the barest of minimums that represent a Customer for our new SaaS product. After all, this entire method is around building and maintaining products as they grow in complexity.
+I am intentionally skipping persistence methods because this explanation is about naming conventions.
+Our first job is going to be setting up subscriptions for Customers. A Customer can have many Subscriptions.
+So now we have a setup like this:
+```crystal
+class Subscription
+  property name : String
+  property rate : Int16
+  property quantity : Int16
+  def initialize(@name, @rate, @quantity)
+  end
+end
+class Customer
+  property name : String
+  property email : String
+  property subscriptions : Array(Subscription) = [] of Subscription
+  def initialize(@name, @email)
+  end
+end
+```
+At this point the relationship between the two objects is clear and the names are simple and imply their intended meaning. Our minds have mental models of what a Customer is and what a Subscription is because of our life experience. We can fill in the implications of what the property and its type mean. The `name` property is relatively clear.
+However, to an AI this kind of naming is less than ideal. It will probably still work, but will progressively become less and less useful as the classes grow in complexity.
+Instead if we change to a more verbose naming convention that adds in contextual meaning, the AI is better able to understand what we are trying to do.
+Let’s focus on the Customer class first and you’ll see what I mean.
+```crystal
+class Customer
+  property first_name : String
+  property last_name : String
+  property email_address : String
+  property list_of_all_active_subscriptions : Array(Subscription) = [] of Subscription
+  def initialize(@name, @email)
+  end
+end
+```
+You may have noticed that a lot has changed and at the same time, we changed very little.
+Notice how explicit the name attributes are now? The name before could have been first, last, middle initial or full name. Who knows? We certainly didn’t have those details before. A more senior developer reading this probably picked up on that quickly!
+We’ve now expanded our `email` to `email_address` because now it’s 100% clear that we intend to store an email address there and some kind of flag that says the email subscription list that the Customer belongs to. It was implied that the value was intended to be an email address, but it’s entirely possible its intended use was not that.
+The changes to our old `subscriptions` property are a bit shocking! Did you have any idea that all you needed to track were the active subscriptions? Maybe during the conversation with a product owner, but the AI would have no idea. By updating the naming we now have a clear purpose given to that property with a contextually significant meaning.
+So far all of the examples are fairly simple and straight forward. In fact, this is already pretty close to what would be considered “good” naming practices. So let’s take this to the next level where there’s a lot more complexity. This is where real business logic becomes messy and far less non-obvious.
+Well the good news is that our little SaaS is growing up and now has more products and all new licensing. The sales team has been getting enterprise customer inquiries and the deal size is so big that the product team is now being told we need to adapt our one Customer to many Subscriptions model to allow for Customers who aggregate into a single billable entity, and prevents these users from adding any subscription items.
+By the way, you have a super short window to implement so there’s no way to take time to architect this thoroughly and perform any data migrations.
+That’s alright, this type of feature request is the Achilles Heel of many code bases. Typically in this kind of scenario we start seeing naming becoming a challenge. Let’s see how we can do it so that it benefits our AI agent assistant, or how our agent would be implementing this feature if we let it drive for us.
+```crystal
+class Customer
+  property first_name : String
+  property last_name : String
+  property email_address : String
+  property list_of_all_active_subscriptions : Array(Subscription) = [] of Subscription
+  property is_this_an_enterprise_customer : Bool
+  def initialize(@first_name, @last_name, @email_address, @is_this_an_enterprise_customer = false)
+  end
+end
+class EnterpriseCustomerBillingEntity
+  property full_legal_entity_name : String
+  property payment_terms_in_number_of_days : Int8
+  property billing_cycle_frequency : Int8
+  property billing_cycle_time_period : String
+  property maximum_customers_according_to_the_contract_limit : Int16
+  property current_count_of_customer_accounts : UInt16
+  def initialize(@full_legal_entity_name, @payment_terms_in_number_of_days, @billing_cycle_frequency, @billing_cycle_time_period, @maximum_customers_according_to_the_contract_limit, @current_count_of_customer_accounts)
+  end
+end
+```
+We now have this new class mixed in that handles the enterprise details. This isn’t about programming the full workflow, it’s about the naming convention used here. A pattern is beginning to emerge.
+Now depending on your level of seniority as a dev, you may read those class attributes and think “yeah that’s basically what I would do, except I’d simplify the names a bit”. And this is when I can begin outlining the general rules to follow when writing code you want an AI assistant to flourish with:
+1. Object attributes with primitive types should be short statements or phrases
+2. Object attributes that are booleans should be phrased as a “yes/no” question or statement
+3. Object attributes that are collections, Arrays or enumerable in some way. Usually it’s good to start the name like “list\_of\_” or “array\_of\_” with a descriptive name of the object types it’s holding.
+Following these guidelines will help keep your naming conventions consistent which helps provide clarity and contextual understanding for your AI agent. It’s also good for you, because you may come back to this code many months or years later and you will not remember the product meeting details but you can clearly read your code.
+### Method & Variable Naming
+Next let’s discuss method and variable naming. This is the most common area where devs can help themselves greatly, but typically fall short. Clever naming can make short variable names for easier readability but the context of what and why quickly disappears into your editors background.
+We left some of the business logic that was in our new feature requirement that we can use for this part. The part we are going to focus on is going to be:
+`prevents these users from adding any subscription items`
+This is something that we can use a process manager to handle while exercising good naming conventions.
+This is a process manager, but it does not use “process” or “manager” in the name. It is acceptable with or without including those details.&#x20;
+```crystal
+class AddSubscriptionToCustomer
+  property customer_to_add_subscription_to : Customer
+  property subscription_to_add_to_customer : Subscription
+  def initialize(@customer_to_add_subscription_to, @subscription_to_add_to_customer)
+  end
+  def add_subscription_to_customer
+    return if @customer_to_add_subscription_to.is_this_an_enterprise_customer
+    @customer_to_add_subscription_to.list_of_all_active_subscriptions << subscription_to_add_to_customer
+  end
+end
+```
+1. The class name for the process manager clearly states what the entire process is attempting to do in a short statement.
+2. The initialize method accepts all of the initial data required to perform the process
+3. The name of the method to start the process is clear and obvious.&#x20;
+This reads very plainly now. The logic in the `return` line reads almost like a complete sentence. This makes the intent very clear for both you the developer and your AI agent assistant.
+The variable names clearly state what the contents are, and the intended use.
+The method name clearly states the action that is being performed. It does not take any parameters because the intended purpose of a process manager is to be initialized with all of the data it needs in order to perform the process it is managing.
+Do you come across code this plainly and clearly written? Maybe. It’s more than likely that it’s plain on that it uses simpler wording and phrasing that is less robust, but still clear. You may have seen `customer_to_update` and considered that good over just `customer`. Maybe you consider the one word better. But your AI agent is going to have less and less of a clear intent by using such simplified wording.
+## The Compounding Rewards of Enhanced Naming
+You are rewarded for clearer naming practices as your files get larger. In fact, you may start implementing these naming conventions and notice something strange. At first, your code completion suggestions from typical AI coding assistants will usually be pretty bad. Only at first, but it’s distinctly noticeable.
+Github Copilot tends to be the worst offender by offering up code snippets that are close but make silly naming mistakes when re-using existing variables. Mistakes such as pluralizing when the variable should be phrased singularly and vice-versa.
+I use Cursor, which has a Copilot++ in editor code suggestion tool and it tends to work much better. It still has lower quality suggestions initially, but as your files grow in size, the suggestions and understanding of what you are trying to do become increasingly more accurate. This includes across files when you’re using Copilot++.
+---
+*Chapter 02 of the AED canon · published **verbatim** from the author's original; the work-in-progress marker at the top is his own, kept as written · continue to [03 · Process Managers](03_process_managers.md) · [reading order](README.md#reading-order)*

03_process_managers.md ADDED Viewed

	@@ -0,0 +1,29 @@

+# Process Manager Conventions
+`_This is a work in progress_`. Updated on 11/24/2025
+Process managers are a convention that AI agents need to organize an unRESTful process. This is commonly domain specific business logic or workflows.
+A process manager name is a statement or phrase that describes what is being done.
+Let’s use an example of building a report. We are just going to describe the feature story that defines this process, and the triggering event. For this example our app has Customers:&#x20;
+`When a list of Customer ID’s is provided, then lock each customers account.`
+Processes start with a “when” keyword, always. Because a process is “when” something happens!
+The second statement “a list of Customer ID’s is provided” tells us the qualifying information we need before this process can be performed. Here were are referencing a “list” aka an Array of IDs which is the attribute type from the Customer model. This could be integers, ULID, UUID’s etc.
+The second half “lock each customers account” is using jargon that represents an operation we define for the business. “Locking” an account for this means: changing an attribute in the Customer model that requires an additional input from the user to confirm their identity and reset their password.
+A process manager can perform many operations at a time, and typically will. The more complicated the process, the more likely to require human intervention to write the complete the process writing.
+If we expand our process statement, it looks like the following:
+`When an array of Integers that represent Customer IDs is provided then loop through each Customer account using the ID to find the correct record and update the necessary attribute that will prevent the Customer from accessing their account.`
+The AI is going to analyze this and ultimately make the determination if any jargon was used, and will ask questions if it can’t understand your intent. It will generally phrase it like I explained above, and may provide more details.
+---
+*Chapter 03 of the AED canon · published **verbatim** from the author's original (last revised 2025-11-24); the work-in-progress marker at the top is his own, kept as written · continue to [04 · Feature Stories](04_feature_stories.md) · [reading order](README.md#reading-order)*

04_feature_stories.md ADDED Viewed

	@@ -0,0 +1,63 @@

+# Agent Enhanced Development - The Whole Process
+## Introduction To What A Feature Request Is
+The idea of “operating” an AI means we need to be able to define it’s “operations” to begin with.
+An operation is essentially the work flow for performing a task. This should encompass multiple steps and possibly “tasks” depending on how you want to define a task.
+To operate an AI agent successfully, we have to shift our mindset on a few topics, such as:
+1. How we define the work that we want to perform
+2. The expected patterns or overall flexibility we have in our code base
+3. Our definition of naming conventions and what "clear" means for us
+4. How we perform development work
+5. The relationship between the code we write and how it reflects the business
+To begin with, we are going to start by more clearly defining what a `feature request` really is. If you've been a developer for any period of time, you've most likely already worked with scrum or agile and been exposed to User Stories. The idea here is pretty similar, however instead of managing the details of the story from a 3rd party tool such as Jira, we are going to manage the details directly with our AI agent that works from our code base.
+Let's define some critical terminology before we move forward.
+**Operation**: the interaction with the AI agent and ensuring it has the correct knowledge and understanding to perform.
+## Our First Feature Request
+Let’s describe some default operations that should come with the framework. I have notes about user stories and I think that operating an AI development agent should mean using Feature Stories to control the behavior of the agent and the outcome.
+First a simple user story:
+`As an **Admin** user, I want to _create_ a new **user** **_and_** _assign_ them to an **account**`
+This story is pretty simple and would mean operations that are required use the typical MVC concepts, which makes things easy to start with.
+The `As an Admin` establishes our persona, scoping the following **action** to be performed. When there is a persona we have chosen, we also know the feature request requires a view and a controller action at a minimum. Our agent knows which views belong to which controller actions, and if we need to create that controller, action, view etc.
+The action is the full statement. It should be a clear summary of what would complete a request/response cycle. If it triggers or enqueues a background job, that should be stated. The action description should also include references to any data models that require a relationship. In the example that’s User and Account. The plurality of the data models dictates the relationships between them, and should use the same Active Record pattern expressions as in Rails.
+The “I want to” part is provided as part of the story builder. The action verb needs to be an HTTP verb of GET POST PUTS PATCH or DELETE followed by the primary data model that is effected.
+A unique verb of “perform” can be used to trigger a workflow that is not RESTful. This is the keyword you primarily use for our unique business logic, aka your special sauce.
+The specially called out “and” in the action is because we follow up a simple RESTful action with a secondary action, and it’s establishing a relationship with an additional record. In this case I highlighted “assign” because it’s an example of company jargon that can alias an Active Record relationship of “belongs to”. These kinds of aliases can be configured with restrictions/conditions before creating a feature story. This story implies it is limited to linking the newly created user to an existing account, and that it does not create a new account.
+A feature story with a persona breaks down it’s structure like this:
+`As a (specify persona), I want to (RESTful verb, or “perform”) (“a” or “multiple”) (data model name of an existing data model) and (AR relationship name/type or “perform”) (data model name or Process Manager name if performing a process)`
+A “persona” is a specialized alias of a User data model type that includes an indication of the “authorization” (ie permissions) level of that model type. For example, an Admin persona could be an alias of a Super Administrator type that has unrestricted permissions, which means they would be using controllers/routes that are scoped to this kind of user.
+Authorization levels work in several ways together to create a robust authorization system.
+- Model type: the model name should represent the general permission level of that group. This is resource based, so an Administrator user type may have its own API and all administrators would generally be considered to use those end-points.
+- Action specific: RESTful verbs have a matching permission level two on the actual model as an attribute. Your app configuration should define if by default the user of that group is allowed or disallowed, and if the flag necessary to perform the action needs to be specified on the models record.
+- Individual resource: individual resources can restrict behavior to model type or record ID’s.
+For unRESTful end-points, the permissions are based on if the model type or specific records of models are allowed to execute an action.
+## Breakdown of The Anatomy of A Feature Request
+TBD
+---
+*Chapter 04 of the AED canon · published **verbatim** from the author's original. The closing `TBD` is the author's own — the anatomy breakdown is genuinely unwritten, and this release candidate marks it rather than papering over it · continue to [05 · Edit-Level Style](05_edit_level_style.md) · [reading order](README.md#reading-order)*

05_edit_level_style.md ADDED Viewed

	@@ -0,0 +1,43 @@

+# 05 · Edit-Level Style
+Chapter 05 of the canon lives at **[CONVENTIONS.md](CONVENTIONS.md)** — six
+rules for how a single line should read, each with before/after Crystal.
+It keeps its original filename and its `#rule-1` … `#rule-6` anchors on
+purpose. Those anchors were published in v1.0.0 and are cited from outside
+this repository; moving them to renumber a chapter would break every one of
+those links for no reader's benefit.
+## Where it sits in the canon
+Chapters 01–04 are the structural doctrine: why models need consistent naming,
+what to name things, how to shape a process manager, how to write a feature
+story. Chapter 05 is narrower and later — it governs the individual edit, once
+the structure is already decided.
+Read in that order it is a fair chapter. Read alone — which is all v1.0.0
+offered — it reads as though AED were a six-item style guide, which it is not.
+That was the gap this release closes.
+- [CONVENTIONS.md#rule-1](CONVENTIONS.md#rule-1) — branch on type with an explicit `if … is_a?`
+- [CONVENTIONS.md#rule-2](CONVENTIONS.md#rule-2) — name the thing; don't make the reader decode a chain
+- [CONVENTIONS.md#rule-3](CONVENTIONS.md#rule-3) — prefer explicit guard clauses to nested ternaries
+- [CONVENTIONS.md#rule-4](CONVENTIONS.md#rule-4) — use full, intention-revealing names
+- [CONVENTIONS.md#rule-5](CONVENTIONS.md#rule-5) — say *why* in a comment, let the code say *what*
+- [CONVENTIONS.md#rule-6](CONVENTIONS.md#rule-6) — one statement per line; let the formatter own the layout
+Plus the [shorthand boundary](CONVENTIONS.md#shorthand-boundary) and the
+[end-of-edit checklist](CONVENTIONS.md#checklist).
+## One known conflict with chapter 02
+CONVENTIONS.md rule 4 offers `expected_state` as an improved name. By
+[chapter 02](02_naming_conventions.md) that name is still under-specified —
+expected by whom, of what, in what units? Chapter 02 is the authority where
+the two disagree. Reconciling the example is tracked for v1.1.0 final.
+---
+*Chapter 05 of the AED canon · continue to
+[06 · Control Flow](06_control_flow.md) ·
+[reading order](README.md#reading-order)*

06_control_flow.md ADDED Viewed

	@@ -0,0 +1,907 @@

+# 06 · Control Flow (CF-1 … CF-11)
+> **Status**: RELEASE CANDIDATE. These eleven rules ship in `v1.1.0-rc.1` as a
+> candidate, not as settled canon. The numbered questions at the end are still
+> open, and the answers may change individual thresholds before `v1.1.0` final.
+> Adopt them if they help; expect the edges to move.
+>
+> **Scope question answered here**: how should AED handle control-flow code
+> whose *syntax* does not naturally align with the reads-like-statements rule?
+> A `while` loop, a `rescue` ladder, or a `spawn` block has no name of its own
+> — the syntax is pure mechanism. AED's answer, developed rule by rule below:
+> **when the syntax can't read like a statement, the *names around it* must
+> say what the syntax is doing.**
+---
+## 0. Census — what actually occurs in our Crystal
+Rules should target real frequency, not theory. Counted with `grep -rE`
+across the two live codebases (regex counts are ceilings — e.g. the ternary
+pattern also matches nilable type signatures; noted where it matters):
+| Pattern | premium template `src/` (107 files, 12,250 lines) | agentc_website `src/` (22 files, 2,163 lines) |
+|---|---:|---:|
+| Leading `if` | 154 | 23 |
+| `if … is_a?` (existing Rule 1) | 6 | 0 |
+| `case` statements | 28 | 3 |
+| `when` branches | 124 | 6 |
+| `case … in` | **0** | **0** |
+| Leading `unless` | 25 | 5 |
+| Any ` unless ` (incl. postfix) | 150 | 24 |
+| `while` | 4 | 8 |
+| `until` | **0** | **0** |
+| `loop do` | 2 | 0 |
+| `break` | 3 | 12 |
+| `next` | 15 | 3 |
+| `return` (all) | 127 | 43 |
+| Guard `return … if` | 36 | 19 |
+| Guard `return … unless` | 58 | 7 |
+| Ternary `? … :` (regex ceiling; true ternaries ≈ half) | 61 | 16 |
+| `begin` | 14 | 2 |
+| `rescue` | 57 | 8 |
+| `ensure` | 13 | 0 |
+| `retry` | **0** | **0** |
+| `raise` | 156 (138 typed error, 14 bare string) | 1 |
+| `spawn` | 4 (2 real code sites) | 0 |
+| `Channel` | 1 | 0 |
+| Concurrency `select` | **0** | **0** |
+| `.each` | 16 | 7 |
+| `.map` | 30 | 5 |
+| `.select`/`.reject` | 13 | 4 |
+| `.try` | 98 | 3 |
+| `&.` shorthand | 116 | 7 |
+| `macro` definitions | 3 | 0 |
+| `{% if %}` compile-time branches | 2 | 0 |
+| `def …?` predicate methods | 195 | 26 |
+| `def …!` bang methods | 10 | 0 |
+**What the census says:**
+- The codebase already leans AED: guard returns (120 across both repos) far
+  outnumber loops (14); typed raises outnumber string raises 10:1; there are
+  195 `?` predicates in the template — the "name the question" culture exists.
+- `case … in`, `until`, `retry`, and concurrency `select` occur **zero**
+  times. We can codify their status cheaply — banning what nobody uses costs
+  nothing and stops an agent from introducing them.
+- The high-frequency gaps that need real rules: `case/when` menus (28+3
+  sites), guard ordering (120 guard returns with no stated ordering rule),
+  `unless` (175 total uses, some compound), `.try` (98 uses — the single
+  biggest "decode a chain" risk), and bare `rescue` (a large share of the 65
+  rescues carry no error name).
+- The website's markdown parser is a legitimate **cursor-loop** cluster
+  (8 `while` + 12 `break` in one file family) — the loop rule must bless that
+  shape, not fight it.
+---
+## The core insight: mechanism syntax vs statement syntax
+The existing skill's rule — *prefer the form that reads like a plain statement
+of intent* — works effortlessly for **expressions**: you pick the spelling
+that reads best. Control flow is different. `while`, `rescue`, `spawn`,
+`{% if %}` are **mechanism keywords**: they say *how* execution moves, never
+*why*. No amount of re-spelling makes `while @i < @lines.size` state an
+intent.
+So for control flow, AED shifts from "pick the readable spelling" to three
+compensating moves, in priority order:
+1. **Name the intent next to the mechanism** — the condition is a named
+   predicate, the body is a named method, the error is a named type, the
+   fiber does a named job.
+2. **Keep the mechanism in one canonical shape** — one blessed way to write
+   each construct, so a reader (or a linting hook) recognizes it instantly.
+3. **Ban the shapes that only ever obscure** — the census shows we already
+   live without them.
+Every rule below is one of those three moves. Format per rule: (a) why the
+raw syntax fights the reading rule, (b) the proposed rule with a crisp name,
+(c) before/after in the skill's voice, (d) the honest cost, (e) the
+mechanical check an agent, linter, or hook can apply.
+---
+## Rule CF-1. `case` is a menu — every branch one bite
+**(a) Why the syntax fights the rule.** A `case` on a *value* (`case action`,
+`case fmt`, `case status_code`) is actually the closest control flow gets to
+a plain statement — *"depending on the action: …"*. It stops reading like a
+statement in exactly two ways: when a branch body grows into a paragraph (the
+reader loses the menu and falls into one dish), and when the subject is an
+expression the reader must evaluate first (`case ENV["AI_DEFAULT_PROVIDER"]?.to_s.downcase`).
+**(b) Proposed rule — "Case is a menu, not a novel."**
+Use `case … when` when branching a **single named value** across **three or
+more** outcomes. Two outcomes is an `if/else` (a menu of two is just a
+choice). Each `when` body is at most ~3 lines or a single named method call —
+if a branch needs a paragraph, extract it to a method whose name is the
+branch's intent. The `case` subject must be a **named local or a plain
+method call**, never an inline expression chain. Always write an explicit
+`else` that states the fallback (`false`, `raise`, or a named default) —
+Crystal's `when` is not exhaustive, so the `else` is where you *say* what
+happens to the unlisted world. `case … in` stays banned per existing Rule 1
+(census: zero uses — nothing to migrate).
+**(c) Before/after.**
+```crystal
+# ✅ AED — a menu: named subject, one bite per branch, spoken fallback
+default_provider = ENV["AI_DEFAULT_PROVIDER"]?.to_s.downcase
+case default_provider
+when "anthropic" then Anthropic::Client.new
+when "openai"    then OpenAI::Client.new
+else                  raise "Unknown AI_DEFAULT_PROVIDER: #{default_provider}"
+end
+# 🚫 subject is a puzzle the reader must evaluate before the menu even starts
+case ENV["AI_DEFAULT_PROVIDER"]?.to_s.downcase
+when "anthropic" then ...
+end
+# 🚫 a two-item "menu" — this is just an if wearing a costume
+case backend
+when :smtp then deliver_smtp(message)
+else            deliver_log(message)
+end
+# ✅ instead:
+if backend == :smtp
+  deliver_smtp(message)
+else
+  deliver_log(message)
+end
+```
+The policy classes are the house exemplar already
+(`src/policies/team_policy.cr`): `case action` with one-line branches
+composed of `?` predicates (`team_lead? || admin_access?`) and `else false`.
+That file reads like an access-control table — which is the point.
+**(d) Cost.** Extracting fat branches adds methods; a reader who wants the
+details takes one hop. Two-branch `case` fans will find the if/else rule
+fussy. Accepted: the menu shape is only worth its visual weight when there is
+an actual menu.
+**(e) Mechanical check.** Flag: `case` whose subject line contains `.` more
+than once or any `?.`/`ENV[`; any `when` body exceeding 3 lines; any `case`
+with fewer than 3 `when` branches; any `case` without `else`; any `case … in`
+(already caught by the compile hook on Grant types — extend to a grep ban).
+---
+## Rule CF-2. Loops state their finish line
+**(a) Why the syntax fights the rule.** `while` states a *continuation
+condition*, but a reader thinks in terms of a *finish line* ("keep going
+until the lines run out"). Worse, `loop do … break` scatters the finish line
+into the body, and an index cursor (`@i`) makes progress invisible — the
+reader must verify the loop advances or they can't trust it terminates.
+**(b) Proposed rule — "Every loop names its finish line and shows its
+step."** Three blessed loop shapes, nothing else:
+1. **Collection walk** — `items.each do |item|` (default; covers most needs).
+2. **Cursor loop** — `while cursor_has_more?` over an explicit cursor, where
+   (i) the condition is a plain comparison or a named `?` predicate, (ii)
+   every `break` inside is a one-line guard whose condition is a named
+   predicate or plain comparison, and (iii) the cursor visibly advances in
+   the body (an `@i += n` a reader can point at). This blesses the website's
+   markdown parser shape (`while @i < @lines.size` … `break unless row?(s)` —
+   `article_markdown.cr` already complies, its break conditions are named
+   predicates like `ordered_item?`, `task_item?`, `row?`).
+3. **Forever loop** — `loop do` only for intentionally unbounded work (the
+   SSE heartbeat in `mcp_sse_controller.cr`), and it must sit inside a method
+   whose **name says it loops** (`run_heartbeat_loop`, `pump_stdout`), with
+   its exit spelled as a guard (`break if client_disconnected?`).
+If a loop body exceeds ~8 lines, extract the body to a method named for one
+iteration's intent (`consume_blockquote`, `emit_table_row`) — the loop line
+then reads *"while there are lines, consume the next block."*
+`until` is **banned** (census: zero uses): `until done?` forces the reader to
+negate in their head; write `while more?`.
+**(c) Before/after.**
+```crystal
+# ✅ AED — cursor loop: named finish line, named break, visible step
+while @i < @lines.size
+  line = @lines[@i].strip
+  break unless ordered_item?(line)
+  emit_ordered_item(line)
+  @i += 1
+end
+# 🚫 the finish line is a negation the reader must invert
+until @i >= @lines.size
+  ...
+end
+# 🚫 forever-loop with an anonymous job and a buried exit
+loop do
+  sleep 15.seconds
+  begin
+    send_event(response, "ping", {time: Time.utc.to_unix})
+  rescue
+    break
+  end
+end
+# ✅ instead: the method name carries the loop's intent
+private def run_heartbeat_loop(response) : Nil
+  loop do
+    sleep 15.seconds
+    break unless send_ping(response) # returns false when the client is gone
+  end
+end
+```
+**(d) Cost.** Extraction adds one hop per fat loop; the "visible step" rule
+occasionally forces an `@i += 1` where a cleverer restructure could avoid the
+cursor entirely. Accepted: termination you can point at beats elegance you
+must simulate.
+**(e) Mechanical check.** Flag: any `until`; any `loop do` in a method whose
+name lacks `loop`/`pump`/`watch`/`poll`; any `while` body > 8 lines; any
+`break` followed by a compound condition (`&&`/`||` on the same line); a
+`while i <`-style loop whose body never reassigns the cursor variable.
+---
+## Rule CF-3. Guards are the bouncer — they stand at the door
+**(a) Why the syntax fights the rule.** An early `return` is invisible in
+prose: a non-technical reader scanning top-to-bottom doesn't naturally know
+that `return nil unless key` means *everything below assumes a key exists*.
+Guards scattered mid-method are worse — the story keeps getting interrupted
+by exits the reader has to fold into their mental state.
+**(b) Proposed rule — "Guards first, story second."** Guard clauses (already
+the house majority style — 120 guard returns across both repos, and existing
+Rule 3 prefers them) get an *ordering and shape* contract:
+- All precondition guards sit in a **contiguous block at the top** of the
+  method, before the first line of the happy path. A reader — technical or
+  not — reads them as a doorman's checklist: *"no ticket, no entry; wrong
+  tag, no entry."* Everything after the blank line is the story with all
+  assumptions established.
+- One guard per line, one idea per guard. A guard's condition is a plain
+  comparison, a named predicate, or a single nil-check — never a compound
+  needing parentheses (extract to a `?` method, see CF-8).
+- A `return` *after* the story has started is allowed only when it is the
+  method's **answer** (the natural end of a branch), not a late-discovered
+  precondition. If you discover a precondition mid-story, either hoist it or
+  extract the remainder into a method with its own door.
+- Guards that reject for a *reason worth documenting* say why on the line
+  above (`# CSRF: state must match what we issued`), per existing Rule 5.
+`src/wire/cose.cr` is the exemplar: five `return nil unless …` guards in a
+row, then the single decrypt statement — the shape *is* the security
+argument.
+**(c) Before/after.**
+```crystal
+# ✅ AED — the bouncer's checklist, then the story
+def verify_password(password : String) : self?
+  return nil if password_digest.empty?
+  return nil unless Crypto::Bcrypt::Password.new(password_digest).verify(password)
+  self
+end
+# 🚫 nested ifs — the reader carries open questions to the last line
+def verify_password(password : String) : self?
+  unless password_digest.empty?
+    if Crypto::Bcrypt::Password.new(password_digest).verify(password)
+      self
+    end
+  end
+end
+# 🚫 a precondition ambushing the reader mid-story
+def publish(article)
+  html = render(article)
+  return if article.draft?   # ← this belonged at the door
+  upload(html)
+end
+```
+**(d) Cost.** Hoisting sometimes evaluates a guard slightly earlier than
+strictly needed (rarely matters; note it when it does). Multiple exit points
+still bother single-exit purists — AED sides with the checklist reader.
+**(e) Mechanical check.** Flag: a `return … if/unless` guard appearing after
+the first non-guard, non-comment statement of a method (heuristic: guard
+lines must be a prefix of the method body); any guard condition containing
+`&&`/`||` (send to CF-8); nesting depth > 2 inside a method that has no
+guards (suggests inversion is available).
+---
+## Rule CF-4. `unless` carries one positive idea
+**(a) Why the syntax fights the rule.** `unless` reads beautifully as an
+English exception — *"return nil unless the state matches"* — right up until
+the condition contains logic. `unless a && b` requires De Morgan in the
+reader's head ("so it runs when… a is false, OR b is false…"). The census
+shows 175 total `unless` uses; most are clean guards, but sites like
+`unless key.algorithm == ES256 && key.curve == P256` (`webauthn/verifier.cr`)
+cross the line.
+**(b) Proposed rule — "`unless` takes one idea."**
+`unless` (postfix or block) may wrap **one positive condition**: a single
+predicate call, a single comparison, or a single presence check. Never
+`unless` with `&&`, `||`, or `!`; never `unless … else` (Crystal allows it;
+AED bans it outright — an inverted two-branch is an `if` written backwards).
+Compound conditions get a named `?` predicate first, then `unless` may carry
+the name. `until` is covered (banned) by CF-2 — same negation tax.
+**(c) Before/after.**
+```crystal
+# ✅ AED — name the compound, then the exception reads like English
+def es256_key?(key) : Bool
+  key.algorithm == COSE::Algorithm::ES256 && key.curve == COSE::EC2Curve::P256
+end
+raise Error.new("expected an ES256 key") unless es256_key?(key)
+# 🚫 the reader must run De Morgan to know when this fires
+unless key.algorithm == COSE::Algorithm::ES256 && key.curve == COSE::EC2Curve::P256
+  raise Error.new("expected an ES256 key")
+end
+# 🚫 unless/else — an if, written in a mirror
+unless info.email_verified
+  reject_signup
+else
+  create_account
+end
+```
+**(d) Cost.** One extra tiny method per compound; occasionally a predicate
+used exactly once. Accepted: the predicate name doubles as documentation and
+as a doc heading (see §Docs).
+**(e) Mechanical check.** Flag: `unless` on a line containing `&&`, `||`, or
+` !`; any `unless … else`; any `until`. All three are plain greps — ideal
+hook material.
+---
+## Rule CF-5. Ternary picks between two spellings of one value
+**(a) Why the syntax fights the rule.** A ternary compresses a branch into a
+breath. That's fine when both arms are *values of the same idea*
+(`success ? "info" : "warning"`), because the reader parses it as one noun
+with two spellings. It fights the rule the moment an arm contains a call
+with effects, another `?`, or the arms are different *actions* — then the
+reader is executing code inside a noun slot.
+**(b) Proposed rule — "Ternary is a value with two spellings, and it gets a
+name."** A ternary is allowed only when **all** hold: both arms are simple
+values (literal, variable, or a single pure call); no nesting; no side
+effects; and the result is immediately **named** — assigned to a variable or
+passed as a named/keyword argument whose name states what it is. Choosing
+between two *actions* is always an `if/else`. Existing Rule 3's ban on
+nested ternaries is subsumed here.
+**(c) Before/after.**
+```crystal
+# ✅ AED — one noun, two spellings, and the noun is named at the call site
+severity: success ? "info" : "warning",
+# ✅ AED — named result
+byte_length = curve == OKPCurve::Ed25519 ? 32 : 57
+# 🚫 two different actions crammed into a noun slot
+logged_in? ? render_dashboard : redirect_to_login
+# 🚫 arms with their own lookups and fallbacks (real shape from icon_component.cr)
+path = name ? (ICONS[name]? || "") : (@attributes["path"]? || "")
+# ✅ instead: the branch is a decision — write it as one
+if name
+  path = ICONS[name]? || ""
+else
+  path = @attributes["path"]? || ""
+end
+```
+**(d) Cost.** Some three-line `if`s where a one-liner "worked". Accepted:
+the one-liner worked for the author; the `if` works for the reader.
+**(e) Mechanical check.** Flag: a line matching the ternary shape that also
+contains a second `?`-operator (nesting), a `!`-suffixed call, `<<`, `=`
+inside an arm, or arms containing `(…)` with further calls; ternaries whose
+result is not assigned or passed as an argument.
+---
+## Rule CF-6. Chains read like a sentence or get named waypoints
+**(a) Why the syntax fights the rule.** `users.select(&.active?).map(&.email)`
+*is* a sentence — "take the active users' emails." The syntax stops
+cooperating when a link needs a multi-line block, when a `.try` hides a nil
+branch mid-chain, or when link three depends on remembering what link one
+produced. At that point the chain is a pipeline the reader must trace, not a
+sentence they can hear. The census makes `.try` the sharpest instance: 98
+uses in the template, many nested (`data["mail"]?.try(&.as_s) || …`), versus
+only ~50 collection-chain links total.
+**(b) Proposed rule — "Two links spoken, three links named."**
+- A chain may have up to **two transformation links**, each in `&.method`
+  shorthand, when it reads aloud as one sentence.
+- Three or more links, or **any** multi-line `do … end` block mid-chain, or
+  any link whose output type isn't obvious from its name → break the chain
+  with **named waypoints**: intermediate variables named for *what the data
+  is at that point* (`active_users`, `member_emails`), not for the operation
+  (`filtered`, `mapped`, `result2`).
+- `.each` (side effects) never follows transformation links in the same
+  chain — name the collection first, then iterate it. A reader distinguishes
+  "computing" from "doing" by the line break.
+- `.try` chains: **one `.try` maximum per expression**, and only the
+  `&.method` shorthand form. Two `.try`s, a `.try` with a block containing
+  logic, or `.try` feeding `||` feeding `.try` → rewrite as an explicit
+  nil-check guard or an `if value = expr` assignment-condition. (This
+  restates existing Rule 2 with a hard threshold.)
+**(c) Before/after.**
+```crystal
+# ✅ AED — two links, one sentence
+member_emails = users.select(&.active?).map(&.email)
+# ✅ AED — waypoints named for what the data IS
+oauth_accounts   = accounts.select(&.oauth?)
+verified_emails  = oauth_accounts.map(&.email).select(&.verified?)
+verified_emails.each { |email| enqueue_welcome(email) }
+# 🚫 the reader holds three intermediate shapes in their head, then side-effects
+accounts.select(&.oauth?).map(&.email).select(&.verified?).each { |e| enqueue_welcome(e) }
+# 🚫 nested try-fallback — three nil-branches hidden in one line (real shape, microsoft.cr)
+email = data["mail"]?.try(&.as_s) || data["userPrincipalName"]?.try(&.as_s) || ""
+# ✅ instead: each source named, the preference order visible as lines
+primary_email  = data["mail"]?.try(&.as_s)
+fallback_email = data["userPrincipalName"]?.try(&.as_s)
+email = primary_email || fallback_email || ""
+```
+**(d) Cost.** More lines and more locals; hot paths allocate an intermediate
+array per waypoint (if profiling ever shows it matters, note the exception
+with a *why* comment per existing Rule 5). Accepted: this codebase reads far
+more than it iterates.
+**(e) Mechanical check.** Flag: ≥3 `.method(` / `&.` links on one expression;
+`.each` preceded by `.map`/`.select`/`.reject` in the same statement; ≥2
+`.try` in one expression; `.try do` block form; waypoint variables named
+`result`, `tmp`, `filtered`, `x2` (existing Rule 4's list, extended).
+---
+## Rule CF-7. Errors are vocabulary; rescues say what they forgive
+**(a) Why the syntax fights the rule.** `begin/rescue` reads like nothing at
+all: a bare `rescue` is the statement *"if anything whatsoever goes wrong,
+do this"* — which is almost never what the author meant and never what the
+reader can verify. Exception flow is invisible control flow: the jump happens
+on a line the reader can't see. The only way it reads like a statement is if
+the **error type carries the sentence**. The census shows the raising side
+already speaks: 138 typed raises vs 14 string raises, and a real error
+vocabulary exists (`WebAuthn::Registration::UnsupportedAttestation`,
+`Storage::FileNotFoundError`, `Authorization::…`). The rescuing side lags:
+a large share of the 65 rescues are bare.
+**(b) Proposed rule — "Raise nouns, rescue by name."**
+- **Raising**: always a typed error from the domain vocabulary; new failure
+  modes mint a new subclass under the module's base `Error` (the house
+  pattern: `class Error < Exception` per module, specific subclasses under
+  it). A bare `raise "string"` is allowed only for
+  configuration-impossible states at boot (`"ANTHROPIC_API_KEY required"`).
+- **Rescuing**: `rescue ex : SpecificError` naming the narrowest type that
+  states what you forgive. A broad `rescue ex` is permitted only at
+  **boundaries** — the outermost edge of a request, a fiber, a mailer
+  delivery, a worker — and must (i) bind `ex`, (ii) log or report it, and
+  (iii) carry a *why* comment stating the boundary ("mailer must never take
+  the request down with it"). A bare `rescue` with no binding and no comment
+  is banned.
+- **Postfix `rescue nil`** only around a *single parse/convert expression*
+  where nil is the honest answer (`Time.parse_rfc2822(date) rescue nil` —
+  the two existing uses both qualify). Never around a call with side effects.
+- **`ensure`** is for cleanup only (close, unlink, reset) — never business
+  logic; if an `ensure` grows past ~3 lines, extract it to a named cleanup
+  method (`ensure … close_worker_pipes`).
+- **`retry`** (census: zero) is banned in its raw form; retrying is a policy,
+  so it must live in a method named for it (`with_retries(attempts: 3) do`)
+  that owns the counter and backoff — a raw `retry` is an unbounded loop
+  wearing an exception costume.
+**(c) Before/after.**
+```crystal
+# ✅ AED — the rescue states exactly what it forgives, and why
+def find_verified(token : String) : Users::Regular?
+  payload = decode_session_token(token)
+  Users::Regular.find(payload.user_id)
+rescue JWT::ExpiredSignatureError
+  # Expired session is a normal event, not an error: the caller re-authenticates.
+  nil
+end
+# 🚫 forgives everything — a typo in decode_session_token now returns nil forever
+def find_verified(token : String) : Users::Regular?
+  Users::Regular.find(decode_session_token(token).user_id)
+rescue
+  nil
+end
+# ✅ AED — broad rescue earns its breadth at a boundary, with the why on record
+spawn do
+  run_heartbeat_loop(response)
+rescue ex
+  # Boundary: a dead client must never crash the server fiber pool.
+  Log.warn(exception: ex) { "SSE heartbeat fiber exited" }
+end
+```
+**(d) Cost.** Naming narrow error types takes real thought (what *can* this
+raise?), and Crystal won't tell you — there are no checked exceptions.
+Sometimes you'll name two types where a bare rescue was one word. Accepted:
+that thought is precisely the documentation the next agent needs; a bare
+rescue is a claim of omniscience.
+**(e) Mechanical check.** Flag: `rescue` at end-of-line or `rescue$` with no
+type and no `ex` binding; `rescue ex` (untyped) with no comment within 2
+lines; `raise "` outside `config/`/boot files; any `retry` keyword; `ensure`
+blocks > 3 lines; postfix `rescue nil` on a line containing `save`/`create`/
+`delete`/`<<`/`=` (side-effect heuristic).
+---
+## Rule CF-8. Three ands make a question method
+**(a) Why the syntax fights the rule.** Boolean operators are the one place
+where "statement-like" degrades *gradually*: `a && b` still reads, `a && b || c && !d`
+is a logic puzzle. The reader shouldn't need parentheses skills to know when
+a branch fires. The template's 195 `?` methods prove the extraction habit
+exists — this rule just fixes the threshold.
+**(b) Proposed rule — "Two operators is a sentence; three is a method."**
+A condition (in `if`, `unless`, `while`, a guard, or a ternary) may contain
+at most **two** boolean operators, and never a *mix* of `&&` and `||`
+without extraction — a mix means precedence, and precedence means the
+reader is parsing, not reading. Beyond that, extract either a **`?` question
+method** (when the concept recurs or belongs to the object:
+`team_lead?`, `es256_key?`) or a **named `Bool` local** (when it's one-off
+and built from locals: `state_matches = …`). The name must be the *positive*
+form of the question — no `not_invalid?`.
+**(c) Before/after.**
+```crystal
+# ✅ AED — the condition IS the sentence
+if oauth_callback_valid?(provider, expected_state, state, code)
+  ...
+private def oauth_callback_valid?(provider, expected_state, state, code) : Bool
+  return false unless provider && expected_state && state && code
+  constant_time_equal?(expected_state, state)
+end
+# 🚫 four conditions and a continuation line — a parser test, not a sentence
+unless provider && expected_state && state && code &&
+       constant_time_equal?(expected_state, state)
+  ...
+# ✅ AED — mixed operators earn a named local even at only three terms
+signature_acceptable = algorithm.rs? || algorithm.ps?
+return unless signature_acceptable && key_present?
+```
+**(d) Cost.** Method count grows; a hostile reviewer can call `?` methods
+"indirection". Accepted — with one honest caveat: the extracted name must
+truly summarize, or you've hidden the puzzle behind a label. Bad name = worse
+than inline. Naming quality falls to existing Rule 4.
+**(e) Mechanical check.** Flag: any condition line with ≥3 of (`&&`, `||`);
+any condition mixing `&&` and `||`; any `if`/`unless`/`while` condition
+spilling to a continuation line; predicate names starting `not_`/`no_`.
+---
+## Rule CF-9. Every fiber gets a job title
+**(a) Why the syntax fights the rule.** Concurrency breaks the deepest
+assumption of statement-reading: that the next line happens next. `spawn do`
+means "meanwhile, elsewhere" — and an anonymous block gives the reader no
+noun to hold on to while the main story continues. Channels are worse:
+`ch.receive` is a sentence missing its subject (*receive what, from whom?*).
+The census says our exposure is small (4 spawns, 1 channel, 0 `select`) but
+the two real sites (`isolated_worker.cr`, `mcp_sse_controller.cr`) are
+exactly the hardest code in the template — small count, maximal reader risk.
+**(b) Proposed rule — "Meanwhile, the *named* worker does its *named* job."**
+- Every `spawn` body is a **single call to a named method** whose name is
+  the fiber's job (`spawn { pump_input_to_child(in_writer, input, writer_done) }`,
+  `spawn { run_heartbeat_loop(response) }`). Never an inline multi-line
+  block: the reader should meet a fiber the way they meet an employee — by
+  title — and only read the job description if they choose to. Crystal's
+  `spawn(name: "heartbeat")` is encouraged in addition (it labels runtime
+  diagnostics) but the method name is the load-bearing part.
+- Every `Channel` variable is named for its **cargo and direction**
+  (`writer_done`, `parsed_events`, `shutdown_requested`) — the existing
+  `writer_done = Channel(Exception?).new(1)` is the exemplar. Bare `ch`
+  banned.
+- A `.receive` reads as *"wait for the writer to be done"* only if the line
+  says so: `writer_error = writer_done.receive`.
+- Concurrency `select` (census: zero): when it arrives, each branch must be
+  a one-line guard-style clause calling a named method — same menu
+  discipline as CF-1.
+- Every fiber body's outermost layer is a boundary rescue per CF-7 — a fiber
+  that dies silently is control flow the reader can never follow.
+*How a statement-reader follows concurrent flow under this rule:* the main
+story reads linearly and each `spawn` line reads as a one-sentence aside —
+"meanwhile, pump input to the child" — and each `receive` reads as
+"wait here for X." The reader never has to interleave two instruction
+streams; they follow one story with named waypoints where the streams touch.
+**(c) Before/after.**
+```crystal
+# ✅ AED — the aside has a title; the join point says what it waits for
+writer_done = Channel(Exception?).new(1)
+spawn { pump_input_to_child(in_writer, input, writer_done) }
+output = drain_child_output(out_reader)
+writer_error = writer_done.receive
+# 🚫 an anonymous ten-line meanwhile — the reader must simulate two timelines at once
+writer_done = Channel(Exception?).new(1)
+spawn do
+  begin
+    in_writer.write(input) unless input.empty?
+    err = nil
+  rescue ex
+    err = ex
+  ensure
+    in_writer.close
+    writer_done.send(err)
+  end
+end
+```
+**(d) Cost.** Method extraction can force explicit parameter passing where a
+closure captured silently — that's several extra tokens per fiber, and
+occasionally a small struct to carry them. Accepted eagerly: silent capture
+is precisely what makes concurrent code unreadable (and, per the `gc_arena`
+warnings, unsafe — a named method's parameter list *is* the audit of what
+the fiber touches).
+**(e) Mechanical check.** Flag: `spawn do`/`spawn {` whose body exceeds 1
+statement; channel locals named `ch`/`chan`/`c`; a `spawn` whose body lacks
+a rescue and whose called method lacks one (approximate: warn on every spawn,
+require the boundary-rescue comment to silence); any `select` branch longer
+than one line.
+---
+## Rule CF-10. `?` asks, `!` warns — and the suffix is a promise
+**(a) Why the syntax fights the rule.** The suffixes are Crystal's built-in
+statement-reading aid — `verified?` reads as a question, `save!` as a
+warning — but only if they're *reliable*. A `?` method returning a `String?`
+"sometimes-value" instead of a `Bool`, or a `!` method that's merely "the
+other version", breaks the reader's trained reflex and silently poisons
+every future read. Census: 195 `?` defs and 10 `!` defs in the template —
+the reflex is trainable; the contract just needs writing down.
+**(b) Proposed rule — "The suffix is a promise."**
+- `def foo?` returns `Bool` — full stop — with one blessed exception: the
+  Crystal-stdlib **maybe-lookup** convention (`session["oauth_state"]?`,
+  `ENV["KEY"]?`, `find_by?`) where `?` means *nil instead of raising*. Both
+  are questions ("is it?" / "is it there?"); nothing else earns the mark.
+- `def foo!` means **raises where `foo` returns nil, or mutates the
+  receiver** — the two Ruby/Crystal senses — and every `!` method's doc
+  comment states *which* danger it warns about, in one line.
+- In conditions, prefer the `?` form over comparison chains
+  (`user.verified?` not `user.verified_at != nil`).
+- Chaining: a `!` call never appears mid-chain (`fetch!.parse.render` hides
+  the raise in the middle of a sentence — the raise belongs on its own
+  line, where a guard or rescue can be seen next to it). A `?` predicate
+  never has its result chained onward (`valid?.to_s` is a smell: a question
+  answers, it doesn't pipeline).
+**(c) Before/after.**
+```crystal
+# ✅ AED — the question mark tells the truth
+def team_member? : Bool
+  @context.try(&.team_membership) != nil
+end
+# 🚫 a "question" that answers with a maybe-string — the reflex is now poisoned
+def admin_role?
+  membership.role if membership.admin?
+end
+# ✅ AED — the raise stands on its own line where the reader can see it
+document = Document.find!(document_id) # raises Grant::Querying::NotFound
+render(document)
+# 🚫 the raise hides mid-sentence
+render(Document.find!(document_id).with_sections)
+```
+**(d) Cost.** The maybe-lookup exception means `?` is *two* promises, not
+one — genuinely a wart, but it's stdlib-load-bearing (98 `.try`s and every
+`[]?` depend on it), so we document it rather than fight it. Some `!`
+doc-comment ceremony.
+**(e) Mechanical check.** Flag: `def …?` with a declared return type other
+than `Bool` outside index/find/lookup names; `def …!` with no doc comment;
+`!`-suffixed call followed by `.` on the same line; `?`-suffixed predicate
+call followed by `.` (excluding `[]?`/`find_by?`-style lookups).
+---
+## Rule CF-11. Macros write code; they don't hide flow
+**(a) Why the syntax fights the rule.** `{% if flag?(:preview_mt) %}` is
+control flow the runtime reader *cannot see executing at all* — the branch
+was taken at compile time, and half the file's text is a ghost. `macro
+included` generates methods that exist nowhere in the source a reader greps.
+Both defeat statement-reading not by being dense but by being **invisible**.
+Census: 3 macro defs, 2 compile-time ifs — rare, so the rule is a fence, not
+a renovation.
+**(b) Proposed rule — "Compile-time branches speak for both worlds."**
+- `{% if %}` / `{% else %}` is allowed only for **platform/flag gating**
+  (`flag?(:preview_mt)`, `flag?(:gc_agentc)`), placed at the **top level of
+  a method or file section** — never interleaved inside a runtime `if`
+  ladder. Each branch's first line is a comment stating which world this is
+  and what the other world does (`# MT builds: forking is unsupported —
+  raise; single-thread builds take the fork path below`). The existing
+  `isolated_worker.cr` / `gc_arena.cr` sites already approximate this.
+- `macro` definitions live only in **concerns and infrastructure**
+  (`src/models/concerns/`, `src/runtime/`), never in controllers/views/
+  business logic. Every `macro included` carries a comment block listing,
+  by name, the methods/columns it generates (`soft_deletable.cr`'s
+  `column deleted_at` style is halfway there — add the roster comment), so
+  grep-for-definition finds a mention even though the def is generated.
+- No macro-generated *runtime branching* whose shape depends on macro logic
+  (a macro that emits different `if` ladders per include is a puzzle box).
+  Generate declarations and delegations; keep decisions in visible code.
+- `{% for %}` (census: zero) — same fence: declaration generation only.
+**(c) Before/after.**
+```crystal
+# ✅ AED — the ghost branch is narrated for the reader of either world
+def self.run(&block : -> Bytes) : Bytes
+  {% if flag?(:preview_mt) %}
+    # MT builds: fork() after threads exist inherits poisoned locks — refuse loudly.
+    raise UnsupportedError.new("IsolatedWorker.run requires the single-threaded runtime")
+  {% else %}
+    # Single-threaded builds: fork, run the block in the child, reap the bytes.
+    run_in_forked_child(block)
+  {% end %}
+end
+# 🚫 compile-time and runtime conditions braided together — nobody can trace this
+{% if flag?(:gc_agentc) %} if ENABLED && {% if flag?(:preview_mt) %} false {% else %} arena_ready? {% end %} ... {% end %}
+```
+**(d) Cost.** The roster comment can drift from what the macro actually
+generates (comments always can); the "concerns only" fence occasionally
+forces a small concern file where an inline macro felt convenient. Accepted:
+invisible code is the single most expensive thing to hand a coding agent.
+**(e) Mechanical check.** Flag: `{% if` on a line that also contains runtime
+`if`/`unless`; `macro ` definitions outside `src/models/concerns/` and
+`src/runtime/`; `macro included` without a comment containing `generates`
+within 3 lines; nested `{%` inside a method body deeper than one level.
+---
+## How these rules feed documentation generation
+AED's premise for docs: **the names are the source of headings.** Prose docs
+rot; names are re-verified by every compile and every review. Control flow is
+where this pays off most, because control flow *is* the behavior readers ask
+about ("when does it refuse?", "what can go wrong?", "what runs in the
+background?"). Each rule above was written so its mandatory names map onto a
+doc section mechanically:
+| Rule | Named artifact | Doc surface it generates |
+|---|---|---|
+| CF-3 Guards first | The guard block of each public method | **"Refuses when…"** bullet list per operation — each guard line becomes one bullet, its *why*-comment becomes the bullet's explanation. The wire/cose.cr guard stack *is* its security doc. |
+| CF-8 Question methods | `?` predicates referenced by guards & branches | **Glossary of business rules** — `team_lead?`, `oauth_callback_valid?` become glossary entries; the predicate body is the definition. Policy classes' `can?` menus render directly as **permission tables** (action × predicate). |
+| CF-1 Case menus | `case` subject + `when` labels + extracted branch methods | **Decision tables** — "depending on `default_provider`: …" — subject is the table title, when-labels are rows, extracted method names are the outcome column. The mandatory `else` becomes the documented fallback row. |
+| CF-2 Loop finish lines | Loop-extracted body methods, `loop`-named methods | **"Process steps"** — `consume_blockquote`, `emit_table_row` list as the pipeline's stages; `run_heartbeat_loop` names itself in ops docs. |
+| CF-7 Error vocabulary | Typed error classes; typed rescues | **"What can go wrong"** section per module — the error subclass tree renders as the failure catalogue; each typed `rescue` site documents which layer absorbs which failure. This is also compliance evidence (SOC2 loves an error taxonomy). |
+| CF-9 Fiber job titles | Spawn-target method names; channel names | **"Background work"** section — every `spawn`-called method is a row: job title, what it waits on (channel names), its boundary rescue. Ops runbooks can be generated from exactly this. |
+| CF-11 Macro rosters | The `generates:` comment roster | **"Generated API"** appendix per concern — the roster is the contract; docs list it verbatim so generated methods are findable. |
+| CF-10 Suffix promises | `!` doc comments | **Danger callouts** — every `!` method's one-line warning surfaces as a ⚠️ note wherever the method is documented. |
+**What does *not* surface:** ternary values, waypoint locals (CF-6), named
+`Bool` locals (CF-8's one-off form), and cursor predicates — these are
+paragraph-level names for the human reading the file, below the doc
+altitude. The doc generator's selection rule is mechanical: **a control-flow
+name surfaces to docs iff it is a method name** (predicates, branch
+extractions, loop bodies, fiber jobs, error classes). Locals stay local.
+A future `docs/` generator (or a doc-writing agent) therefore needs only:
+method names + `?`/`!` suffixes + guard blocks + case labels + error class
+tree + spawn targets — all extractable with the same grep-grade tooling as
+the mechanical checks in (e). That symmetry is deliberate: **the linter's
+tokens and the doc generator's tokens are the same tokens.**
+---
+## Implementation sketch (if adopted)
+1. Add the accepted rules to `.claude/skills/aed-conventions/SKILL.md` as a
+   "Control flow" section, keeping the existing 6 rules and voice; extend
+   the end-of-edit checklist with one line per rule.
+2. Extend `.claude/hooks/crystal_check.sh` (or a sibling `aed_lint.sh`) with
+   the grep-grade checks from each rule's (e) — start **warn-only**, promote
+   to blocking per-rule once the existing codebase is swept. Candidates for
+   custom Ameba rules later; greps first (same engine, zero deps).
+3. Sweep order by census-weighted payoff: (1) bare rescues → typed/commented
+   (~40 sites), (2) nested `.try` fallbacks (~a dozen sites), (3) compound
+   `unless` (+ the two `spawn do` bodies), (4) case menus without `else`.
+   The website's markdown parser needs no changes — it already conforms to
+   CF-2's cursor-loop shape.
+---
+## Open questions before v1.1.0 final
+These are the thresholds still under review. Each rule above is usable today;
+what is unsettled is exactly where the line falls, not whether the rule holds.
+Opinions are welcome in
+[Discussions](https://github.com/AgentC-Consulting/aed-conventions/discussions).
+1. **Case threshold (CF-1):** Adopt "3+ branches or use if/else", every
+   `when` body ≤ 3 lines, mandatory `else`? Or allow 2-branch `case` when
+   the subject name carries weight?
+2. **Ban `until` outright (CF-2/CF-4)?** Census shows zero uses, so it's
+   free today — but it's idiomatic Crystal and some readers find
+   `until done?` natural. Ban, or allow with single-predicate conditions?
+3. **Guard contiguity (CF-3):** Enforce "all guards before the first story
+   statement" as a hard rule, or as a default with a *why*-comment escape
+   hatch for genuinely late preconditions?
+4. **Bare `rescue ex` at boundaries (CF-7):** Is comment-plus-log sufficient
+   license, or do you want a named helper (`swallowing_errors(context) do`)
+   so boundaries are greppable as one idiom?
+5. **`.try` hard cap (CF-6):** One `.try` per expression is aggressive given
+   98 existing uses — adopt as blocking for new code and sweep old, or
+   warn-only permanently?
+6. **Spawn body = single named call (CF-9):** Apply retroactively to the two
+   existing spawn sites (`isolated_worker.cr`, `mcp_sse_controller.cr`) in
+   the sweep, or grandfather them with comments?
+7. **Enforcement vehicle:** extend `crystal_check.sh` with warn-only greps,
+   write custom Ameba rules, or both (greps now, Ameba when stable)?
+8. **Docs pipeline:** is the "method names surface, locals don't" selection
+   rule right for the doc generator, and which doc surface should be built
+   first — permission tables from policies (cheapest, highest compliance
+   value) or "What can go wrong" from the error tree?
+9. **Ternary strictness (CF-5):** the `success ? "info" : "warning"`
+   argument-position form is blessed; do you also want to allow simple
+   ternaries inside string interpolation (common in view components), or
+   force extraction there too?
+10. **Where does this land?** Fold into the existing SKILL.md as one
+    "Control flow" section (one skill, longer), or a sibling
+    `aed-control-flow` skill file referenced from the main one (two hops,
+    shorter files)?
+---
+*Chapter 06 of the AED canon · the census and code shapes above are drawn from
+AgentC Consulting's own production Crystal, so the rules target real frequency
+rather than theory · back to the [reading order](README.md#reading-order)*

07_how_the_workflow_runs.md ADDED Viewed

	@@ -0,0 +1,13 @@

+# How Agent Enhanced Development Work Flows - Local Models
+Typical development processes are that you focus on small steps at a time to scaffold out an idea and then focus on the logic flow. This usually means a lot of saving and rapid iteration. This is actually the least productive way to work with an agent enhanced development process.
+When you are first starting out using an AI agent to assist with developing your app, the temptation is to continue using it for the quick iterative feedback like we currently get from a “write, save, retry” development process. However, with an AI agent enhancing our development process, we are rewarded for planning in detail, and using our natural language. By that I mean, writing and building feature requests in large batches and letting the AI run over many features.
+The agent should be driving the majority of the development, and you should be able to walk away and do something else. It’s a great way to end a day of planning, and then let your laptop sit for a time while the agent runs. It’ll spend the time it needs until it succeeds at building a thorough feature, including your tests.
+This means you can plan your time so that your agent is building your app while you’re typically away from your computer, this way you’re maximizing your local hardware availability while getting the benefits.
+---
+*Chapter 07 of the AED canon · published **verbatim** from the author's original · back to the [reading order](README.md#reading-order)*

ADOPTION.md ADDED Viewed

	@@ -0,0 +1,167 @@

+# Adoption log — the dated record of intents
+Every rule change, publication, and license event gets a dated entry here at
+the time it happens, and every published version is a **signed git tag**
+mirrored to independently-operated hosts. Forward from first publication, this
+log plus the tag history is the public, timestamped record of when each idea
+entered the canon.
+Entries marked *(reconstructed)* describe practice that predates this public
+repository; they are honest reconstructions, not contemporaneous records — the
+contemporaneous private evidence exists and is referenced where it may later be
+published.
+---
+## 2026-07-29 — v1.1.0-rc.1: the original canon published, control flow added
+**Practiced since 2024; first published here 2026-07-29.**
+v1.0.0 published six edit-level style rules and nothing else. Readers — and
+the maintainer — noted that the repository did not contain the doctrine AED
+is actually named for: the token-window rationale, the verbose-naming
+conventions, process managers, and feature stories all existed as private
+notes dating to 2024-06-03 and had never been published. `v1.1.0-rc.1`
+publishes them.
+**Restored, verbatim from the author's originals** (authored 2024-06-03,
+`process_manager_conventions.md` last revised 2025-11-24). These are published
+as written, including the author's own work-in-progress markers and one
+unfinished section marked `TBD`; nothing was rewritten or smoothed:
+- `01_why_models_need_this.md` — the token-window explanation (excerpt of 02,
+  lifted to the front of the reading order)
+- `02_naming_conventions.md` — `list_of_` naming, boolean-as-question naming,
+  attributes as short statements, and the compounding argument
+- `03_process_managers.md` — the "when" grammar
+- `04_feature_stories.md` — personas, operations, authorization levels
+- `07_how_the_workflow_runs.md` — the batch-plan-and-walk-away rhythm
+- `quick_reference.md` — the cheat sheet
+**Added:**
+- `06_control_flow.md` — CF-1 through CF-11, developed 2026-07-07 against a
+  census of two live production codebases. Ships as a **release candidate**:
+  the rules hold, the exact thresholds are still open, and the open questions
+  are listed at the end of the file.
+- `evidence/` — the small-model comprehension benchmark (AED 60/60 vs
+  conventional 54/60, Claude Haiku, blind-answered and blind-graded) and its
+  raw per-probe data, with the method's limits stated up front. Run
+  2026-07-07.
+**Kept, repositioned:** the six v1.0.0 rules remain at `CONVENTIONS.md` with
+their `#rule-1` … `#rule-6` anchors untouched, indexed as chapter 05 of the
+canon. The anchors were published in v1.0.0 and are cited externally;
+renumbering them into a new filename would have broken those links to no
+reader's benefit.
+**Known conflict, tracked not hidden:** `CONVENTIONS.md` rule 4 offers
+`expected_state` as an improved name; by `02_naming_conventions.md` that name
+is still under-specified. Chapter 02 is the authority. Reconciling the
+example is tracked for v1.1.0 final.
+**Why a release candidate:** the CF thresholds and that naming conflict are
+genuinely unsettled, and this republication changes what the repository *is*
+rather than adding to it. Publishing as `-rc.1` puts the material where it can
+be fetched and argued with, without asserting that the edges are final. Whether
+the final tag is `v1.1.0` or `v2.0.0` is deliberately left open.
+**Published surfaces:**
+- Signed tag `v1.1.0-rc.1`:
+  <https://github.com/AgentC-Consulting/aed-conventions/releases/tag/v1.1.0-rc.1>
+- Single-file bundle `dist/aed-v1.1.0-rc.1.md` — the whole canon in reading
+  order, fetchable in one request, generated by `scripts/build_bundle.sh`
+- Hugging Face dataset (org-owned):
+  <https://huggingface.co/datasets/agentc-consulting/aed-conventions>
+The tag lives on the `release/v1.1.0-rc.1` branch. `main` remains at `v1.0.0`
+until this candidate is promoted, so anyone fetching the stable line is
+unaffected.
+---
+## 2026-07-07 — Six core rules written down and licensed (pre-publication)
+**Practiced since ~late 2025, first published 2026-07-07.** *(reconstructed)*
+The six core rules (branch-on-type, name-the-thing, guard clauses,
+intention-revealing names, why-comments, formatter-owned layout) were not
+designed as a standalone document — they emerged from production
+Agent-Enhanced Development on AgentC's own application and website
+codebases (Crystal/Amber, Grant ORM) during 2025–2026, tested against real
+agent edits before ever being written down. No contemporaneous public record
+exists for that emergence period, so "late 2025" here is deliberately
+approximate rather than implying more precision than the evidence supports;
+the contemporaneous private evidence exists and whether/when to publish it
+is a separate, later decision.
+On 2026-07-07 the rules were written down in full for the first time as
+`CONVENTIONS.md` in this repository, with four before/after example files
+added under `examples/`, and licensed:
+- **Prose and documentation** — [CC BY 4.0](LICENSE).
+- **Code examples** (`examples/`) — [MIT](LICENSE-EXAMPLES).
+Control-flow rules (loops, guard ordering, rescues, fibers, macros) were
+drafted internally during the same period and are held back from this
+publication; they are targeted for a signed `v1.1.0` after their own review
+(see `CONVENTIONS.md` → Status and versioning).
+*Note on "published": this entry records the rules being committed to this
+repository's local history. The repository going live on GitHub, with a
+signed `v1.0.0` tag and mirrors on GitLab and Codeberg, is a separate, later
+step — a following entry will record that date and the resulting URLs once
+it happens.*
+---
+## 2026-07-07 — Canonical repository goes public; v1.0.0 signed and tagged
+The repository went live on GitHub as the canonical home of the AED
+conventions, and `v1.0.0` was signed with the AgentC Consulting org key
+and pushed with `--follow-tags`. The org public key is published in this
+repo as [`agentc-signing-pubkey.asc`](agentc-signing-pubkey.asc); see
+[README.md § Verifying signed tags](README.md#verifying-signed-tags) for the
+verify command. Note: because that key is not (yet) registered to any
+GitHub account, GitHub's own UI shows the tag/commits as "Unverified" —
+this is a GitHub account-linking limitation, not a problem with the
+signature itself; `gpg --verify` against the published key is the
+authoritative check. The GPG signature is the authoritative provenance and
+carries the org identity above; the tag object's `tagger` field instead
+shows the maintainer's personal git identity, since that reflects who ran
+the `git tag` command locally — this is expected. Also note: the tag
+object's timestamp is 2026-07-08 UTC (18:51:51 PDT on 2026-07-07, the date
+this entry is dated to), since the `-0700` offset carries it past midnight
+UTC.
+**Live URLs:**
+- Canonical repository: <https://github.com/AgentC-Consulting/aed-conventions>
+- Signed tag `v1.0.0`: <https://github.com/AgentC-Consulting/aed-conventions/releases/tag/v1.0.0>
+- Discussions (enabled): <https://github.com/AgentC-Consulting/aed-conventions/discussions>
+- Hugging Face seed dataset (v0): <https://huggingface.co/datasets/crimson-knight/aed-conventions-examples> —
+  four before/after pairs drawn from `examples/`, dual-licensed matching this
+  repo. Published under the maintainer's existing personal HF namespace
+  (`crimson-knight`) rather than an `AgentC-Consulting` org, because that org
+  does not yet exist on Hugging Face; an org card and an org-owned copy of
+  this dataset are follow-up work once the org exists (owner action).
+**Not yet live (tracked, not forgotten):**
+- **GitLab and Codeberg mirrors** (`scripts/push_mirrors.sh`) — both hosts
+  require credentials (an SSH key trusted by this machine, and, for
+  Codeberg, an accepted host key) that are not present on the publishing
+  machine. The script is inert until an owner configures the `gitlab` and
+  `codeberg` git remotes; it will then push `main` and all tags with one
+  command. Until the mirrors exist, GitHub is the sole host — the
+  "independent corroboration" property described in the plan does not yet
+  hold and should not be assumed.
+- **Hugging Face org card** — *unblocked 2026-07-29*: the
+  `agentc-consulting` organization now exists on Hugging Face, and the
+  v1.1.0-rc.1 canon is published there as an org-owned dataset. The v0
+  examples dataset still sits in the personal `crimson-knight` namespace;
+  moving or duplicating it under the org is follow-up work.
+- **dev.to posts A and B** — drafts exist in `drafts/` and await the owner's
+  voice review before either is scheduled; nothing has been published to
+  dev.to.

CITATION.cff ADDED Viewed

	@@ -0,0 +1,39 @@

+cff-version: 1.2.0
+message: >-
+  If you apply or reference the AED conventions, please cite this repository.
+title: "AED Conventions — Agent-Enhanced Development: Code That Reads Like Statements"
+type: software
+authors:
+  - family-names: Tucker
+    given-names: Seth
+    email: st@agentc.consulting
+    affiliation: AgentC Consulting
+  - name: AgentC Consulting
+    website: "https://agentc.consulting"
+abstract: >-
+  Code conventions for codebases written, reviewed, and maintained by humans
+  and coding agents together. The guiding rule: prefer the form that reads
+  like a plain statement of intent; reach for shorthand only when it makes
+  the intent clearer, never just shorter. Covers the token-window rationale,
+  naming doctrine, process managers, feature stories, edit-level style, and
+  control flow (CF-1 through CF-11), with before/after Crystal examples, a
+  machine-checkable end-of-edit checklist, and a small-model comprehension
+  benchmark.
+repository-code: "https://github.com/AgentC-Consulting/aed-conventions"
+url: "https://agentc.consulting"
+keywords:
+  - code-conventions
+  - agent-enhanced-development
+  - coding-agents
+  - readability
+  - crystal
+  - style-guide
+date-released: 2026-07-29
+version: 1.1.0-rc.1
+license:
+  - CC-BY-4.0
+  - MIT
+license-url: "https://github.com/AgentC-Consulting/aed-conventions/blob/main/README.md#license"
+# NOTE: dual license — CC BY 4.0 covers the prose/documentation (LICENSE),
+# MIT covers the code examples under examples/ (LICENSE-EXAMPLES). See the
+# README's License section for the split.

CONVENTIONS.md ADDED Viewed

	@@ -0,0 +1,140 @@

+# AED Conventions — Code That Reads Like Statements
+**Agent-Enhanced Development (AED)** is how [AgentC Consulting](https://agentc.consulting)
+writes code that both humans and coding agents can read, change, and review
+with the least friction. The guiding rule is simple:
+> **Prefer the form that reads like a plain statement of intent. Reach for
+> shorthand only when it makes the intent _clearer_, never just shorter.**
+Clever, compressed syntax saves the author a few keystrokes and costs every later
+reader (human or agent) a re-parse. In an agent-driven codebase, that trade is
+almost always wrong: the code is read and modified far more often than it is
+written. Optimize for the reader.
+These conventions are the *readability* half of the practice. Their
+*correctness* companion is edit-time verification: run the compiler's type
+check (for Crystal, the compiler frontend with `--no-codegen`) on every edited
+file so mistakes surface immediately, not minutes later in a full build. AED
+keeps the code clear; the edit-time check keeps it compiling. In our own
+tooling this runs automatically after every agent edit — wire the equivalent
+into whatever harness your agents use.
+The examples below are Crystal, because that is what we build with. The rules
+are about reading, not syntax.
+---
+## The rules (with Crystal examples)
+<a id="rule-1"></a>
+### 1. Branch on type with an explicit `if … is_a?`, not a clever `case`
+`case … in` demands *exhaustive* matching, and in codebases using the Grant ORM
+it trips over Grant's `Grant::Base+` type inference (`Error: case is not
+exhaustive. Missing types: Grant::Base`). `case … when .is_a?(T)` (the
+dot-receiver sugar) compiles but reads like a puzzle. An ordinary `if` reads
+like a sentence.
+```crystal
+# ✅ AED — reads like a statement
+if user.is_a?(Users::Regular)
+  session[:user_type] = "regular"
+  session[:session_version] = user.session_version
+else
+  session[:user_type] = "admin"
+end
+# 🚫 trips Grant inference AND hides intent
+case user
+in Users::Regular then ...
+in Users::Admin   then ...
+end
+# 🚫 compiles, but the leading dot is a riddle
+case user
+when .is_a?(Users::Regular) then ...
+end
+```
+<a id="rule-2"></a>
+### 2. Name the thing; don't make the reader decode a chain
+```crystal
+# ✅ AED
+expected_state = session["oauth_state"]?
+return unless expected_state && constant_time_equal?(expected_state, state)
+# 🚫 terse, but the reader has to hold three operations in their head
+return unless session["oauth_state"]?.try { |s| constant_time_equal?(s, state) }
+```
+<a id="rule-3"></a>
+### 3. Prefer explicit guard clauses to nested ternaries / one-liners
+```crystal
+# ✅ AED
+return nil if password_digest.empty?
+return nil unless Crypto::Bcrypt::Password.new(password_digest).verify(password)
+self
+# 🚫 dense
+password_digest.empty? ? nil : (Crypto::Bcrypt::Password.new(password_digest).verify(password) ? self : nil)
+```
+<a id="rule-4"></a>
+### 4. Use full, intention-revealing names
+Methods and locals are sentences-in-miniature: `establish_session`,
+`invalidate_all_sessions`, `find_or_create_from_oauth`, `expected_state`. Avoid
+`do_it`, `tmp`, `x`, `res2`. A good name removes the need for a comment.
+<a id="rule-5"></a>
+### 5. Say *why* in a comment, let the code say *what*
+Comments earn their place by explaining intent, security rationale, or a
+non-obvious constraint — not by restating the line. The house style: a
+session-establishing method carries a comment stating the fixation attack it
+prevents; an encrypted column carries a comment stating what the encryption
+protects and why. If a comment could be deleted with no loss because the code
+already says it, delete it.
+<a id="rule-6"></a>
+### 6. One statement per line; let the formatter own the layout
+Run `crystal tool format` (or your language's canonical formatter) as part of
+every edit. Canonical formatting means every reader and every diff sees the
+same shape.
+---
+<a id="shorthand-boundary"></a>
+## When shorthand IS the clearer form
+AED is "clarity first," not "verbose always." Idioms that are *more* readable are
+encouraged: `arr.map(&.name)`, `value.try(&.to_i64?)`, a `?`-suffixed predicate,
+a single well-named guard expression. The test is always: **does a reader who has
+never seen this code understand the intent on first pass?** If yes, keep it. If
+they have to mentally execute it, expand it.
+---
+<a id="checklist"></a>
+## Checklist before you finish an edit
+- [ ] Type branches use explicit `if … is_a?` (not `case … in` against Grant types).
+- [ ] No one-liner hides more than one operation from the reader.
+- [ ] Names state intent; no `tmp`/`x`/`res2`.
+- [ ] Comments explain *why*, never restate *what*.
+- [ ] `crystal tool format` is clean.
+- [ ] The edit-time type check passed (no `case is not exhaustive`, no undefined methods).
+---
+## Status and versioning
+This document is the public canon of the AED conventions, versioned by signed
+git tags. Rules covering control flow (loops, guards, rescues, fibers, macros)
+are drafted and under internal review; they will land here as a tagged minor
+version. The [ADOPTION.md](ADOPTION.md) log records, with dates, when each rule
+entered practice and when it was published.

LICENSE ADDED Viewed

	@@ -0,0 +1,42 @@

+AED Conventions — Prose License (CC BY 4.0)
+Copyright (c) 2026 AgentC Consulting
+This applies to the prose and documentation in this repository — README.md,
+CONVENTIONS.md, ADOPTION.md, llms.txt, drafts/, CITATION.cff's descriptive
+text, and all other non-code content — licensed under the Creative Commons
+Attribution 4.0 International License (CC BY 4.0).
+Code examples under examples/ are licensed separately under MIT — see
+LICENSE-EXAMPLES. This dual-license structure is explained in README.md.
+To view the full legal text of this license, visit:
+https://creativecommons.org/licenses/by/4.0/legalcode
+Human-readable summary (this summary is not a substitute for the license):
+You are free to:
+  - Share — copy and redistribute the material in any medium or format
+  - Adapt — remix, transform, and build upon the material
+  for any purpose, even commercially.
+Under the following terms:
+  - Attribution — You must give appropriate credit to AgentC Consulting
+    (https://agentc.consulting), provide a link to this license, and
+    indicate if changes were made. You may do so in any reasonable manner,
+    but not in any way that suggests AgentC Consulting endorses you or
+    your use.
+  - No additional restrictions — You may not apply legal terms or
+    technological measures that legally restrict others from doing
+    anything the license permits.
+No warranties are given. The license may not give you all of the
+permissions necessary for your intended use. For example, other rights
+such as publicity, privacy, or moral rights may limit how you use the
+material.
+Full legal code: https://creativecommons.org/licenses/by/4.0/legalcode
+Deed (plain-language summary): https://creativecommons.org/licenses/by/4.0/

LICENSE-EXAMPLES ADDED Viewed

	@@ -0,0 +1,27 @@

+MIT License
+Copyright (c) 2026 AgentC Consulting
+This applies to the code examples in this repository's examples/ directory
+(the "Software"). The surrounding prose and documentation (README.md,
+CONVENTIONS.md, ADOPTION.md, llms.txt, drafts/, and all other non-code
+content) is licensed separately under CC BY 4.0 — see LICENSE. This
+dual-license structure is explained in README.md.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of the Software, to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the
+following conditions:
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

README.md ADDED Viewed

	@@ -0,0 +1,87 @@

+---
+license: cc-by-4.0
+language:
+  - en
+tags:
+  - code
+  - code-conventions
+  - coding-agents
+  - agent-enhanced-development
+  - style-guide
+  - crystal
+pretty_name: "AED Conventions — Agent-Enhanced Development"
+size_categories:
+  - n<1K
+---
+# AED Conventions — Agent-Enhanced Development
+**Version `v1.1.0-rc.1` — release candidate.**
+Code conventions for codebases written, reviewed, and maintained by humans
+*and* coding agents together. The guiding rule:
+> **Prefer the form that reads like a plain statement of intent. Reach for
+> shorthand only when it makes the intent _clearer_, never just shorter.**
+This dataset is a mirror. The **canonical source** is
+<https://github.com/AgentC-Consulting/aed-conventions>, and if the two ever
+disagree, the repository wins. Maintained by
+[AgentC Consulting](https://agentc.consulting).
+## What's here
+Chapters 01–04, 07 and `quick_reference.md` are the author's original notes
+(written 2024-06-03; `03_process_managers.md` revised 2025-11-24), published
+**verbatim** — including his own work-in-progress markers and one section still
+marked `TBD`. Chapters 05–06 and the evidence are later work.
+| File | Contents |
+|---|---|
+| `dist/aed-v1.1.0-rc.1.md` | **Everything, in one file, in reading order** — start here |
+| `01_why_models_need_this.md` | Token windows: why naming carries so much weight for a model |
+| `02_naming_conventions.md` | `list_of_` naming, boolean-as-question naming, attributes as short statements |
+| `03_process_managers.md` | The "when" grammar for business processes |
+| `04_feature_stories.md` | Personas, operations, authorization levels |
+| `CONVENTIONS.md` | Chapter 05 — six edit-level style rules with before/after Crystal |
+| `06_control_flow.md` | CF-1…CF-11 — `case`, loops, guards, rescues, fibers, macros |
+| `07_how_the_workflow_runs.md` | Plan in batches, let the agent run, walk away |
+| `quick_reference.md` | The cheat sheet |
+| `examples/` | Runnable before/after Crystal files |
+| `evidence/` | Small-model comprehension benchmark + raw per-probe data |
+| `llms.txt` | Machine-readable map, ordered to match the reading order |
+## Evidence, with its limits
+`evidence/haiku_comprehension_report.md` reports AED-style Crystal scoring
+**60/60** against **54/60** for conventional compressed style, on 10 snippet
+pairs blind-answered by Claude Haiku and blind-graded.
+Read the stated limits before citing it: n=10 pairs, one small model, a single
+run with no variance estimate, a model grader rather than a human one, and the
+snippet pairs were authored by the same party that authored the conventions.
+It is a **directional signal consistent with the hypothesis, not proof of it**.
+## Status
+This is a **release candidate**. Two things are unsettled: the CF-1…CF-11
+thresholds (open questions are listed at the end of that chapter), and one
+naming example in `CONVENTIONS.md` that conflicts with `02_naming_conventions.md`
+— chapter 02 is the authority where they disagree.
+## Citation
+See `CITATION.cff`. In short:
+> Tucker, Seth, and AgentC Consulting. *AED Conventions — Agent-Enhanced
+> Development: Code That Reads Like Statements*, v1.1.0-rc.1, 2026.
+> https://github.com/AgentC-Consulting/aed-conventions
+## License
+Dual-licensed, matching the canonical repository:
+- **Prose and documentation** — [CC BY 4.0](LICENSE). Reuse and adapt freely,
+  with credit to [AgentC Consulting](https://agentc.consulting).
+- **Code under `examples/`** — [MIT](LICENSE-EXAMPLES). Take it freely, with or
+  without credit.

dist/aed-v1.1.0-rc.1.md ADDED Viewed

	@@ -0,0 +1,1751 @@

+# AED Conventions — the complete canon (v1.1.0-rc.1)
+> **This file is generated.** It is every chapter of
+> [AED Conventions](https://github.com/AgentC-Consulting/aed-conventions)
+> concatenated in reading order, so the whole thing can be fetched with one
+> request or pasted into one context window. The repository is canonical; if
+> this file and the repository disagree, the repository wins.
+>
+> Fetch the newest copy:
+> `https://raw.githubusercontent.com/AgentC-Consulting/aed-conventions/v1.1.0-rc.1/dist/aed-v1.1.0-rc.1.md`
+>
+> Chapters 01–04, 07 and the quick reference are the author's original notes,
+> published verbatim — including his own work-in-progress markers. Chapter 05
+> (`CONVENTIONS.md`) and chapter 06 are later work.
+>
+> Licensed CC BY 4.0 (prose) and MIT (code examples) — AgentC Consulting,
+> https://agentc.consulting
+## Contents
+- 01 · Why Models Need This — `01_why_models_need_this.md`
+- Naming Conventions Overview for Agent Enhanced Development (AED or AE-dev) — `02_naming_conventions.md`
+- Process Manager Conventions — `03_process_managers.md`
+- Agent Enhanced Development - The Whole Process — `04_feature_stories.md`
+- AED Conventions — Code That Reads Like Statements — `CONVENTIONS.md`
+- 06 · Control Flow (CF-1 … CF-11) — `06_control_flow.md`
+- How Agent Enhanced Development Work Flows - Local Models — `07_how_the_workflow_runs.md`
+- Quick Reference - AED Cheat Sheet — `quick_reference.md`
+---
+<!-- source: 01_why_models_need_this.md -->
+## 01 · Why Models Need This
+*Excerpted **verbatim** from the author's `naming_conventions.md`, lifted to the
+front of the reading order because it explains why every later rule exists.
+The complete original — with this passage in place — is
+[02_naming_conventions.md](https://github.com/AgentC-Consulting/aed-conventions/blob/v1.1.0-rc.1/02_naming_conventions.md).*
+---
+Naming conventions are one of the ways that drive the agent enhanced development workflow. The reason for this is that AI models use token windows to understand the context of things.&#x20;
+### Basic Explanation of Tokens & Token Window
+AI models, specifically LLMs, use tokens to represent groups of text. For example the statement:
+`I want to create a new user and assign them to an account.`
+For this example I’ll use Llama 3 to tokenize this prompt. When we tokenize this prompt, it turns into these tokens:
+\`
+```
+'I'
+' want'
+' to'
+' create'
+' a'
+' new'
+' user'
+' and'
+' assign'
+' them'
+' to'
+' an'
+' account'
+'.'
+```
+The extra spaces inside of the single quotes here is to highlight that spaces can be part of a token. Now when the AI model is scanning through the prompt, it’s going to read a group of tokens at a time, shifting down as it processes. For this example I’ll use a 8 token window, shifting 4 tokens at a time so there is some overlap.
+Starting token window `’I want to create a new user and’`
+Next token window `’ a new user and assign them to an’`
+Final token window `‘ assign them to an account.’`
+This window is typically larger than this, but for this example it illustrates how as the window shifts and the LLM model associates groups of tokens. This association is how the relationship of a flow of words is established and influences the direction that the model computes. This is why a naming convention needs to be very consistent.
+---
+*Chapter 01 of the AED canon · continue to
+[02 · Naming Conventions](https://github.com/AgentC-Consulting/aed-conventions/blob/v1.1.0-rc.1/02_naming_conventions.md) ·
+[reading order](https://github.com/AgentC-Consulting/aed-conventions/blob/v1.1.0-rc.1/README.md#reading-order)*
+---
+<!-- source: 02_naming_conventions.md -->
+## Naming Conventions Overview for Agent Enhanced Development (AED or AE-dev)
+`_This is a work in progress_`
+Naming conventions are one of the ways that drive the agent enhanced development workflow. The reason for this is that AI models use token windows to understand the context of things.&#x20;
+### Basic Explanation of Tokens & Token Window
+AI models, specifically LLMs, use tokens to represent groups of text. For example the statement:
+`I want to create a new user and assign them to an account.`
+For this example I’ll use Llama 3 to tokenize this prompt. When we tokenize this prompt, it turns into these tokens:
+\`
+```
+'I'
+' want'
+' to'
+' create'
+' a'
+' new'
+' user'
+' and'
+' assign'
+' them'
+' to'
+' an'
+' account'
+'.'
+```
+The extra spaces inside of the single quotes here is to highlight that spaces can be part of a token. Now when the AI model is scanning through the prompt, it’s going to read a group of tokens at a time, shifting down as it processes. For this example I’ll use a 8 token window, shifting 4 tokens at a time so there is some overlap.
+Starting token window `’I want to create a new user and’`
+Next token window `’ a new user and assign them to an’`
+Final token window `‘ assign them to an account.’`
+This window is typically larger than this, but for this example it illustrates how as the window shifts and the LLM model associates groups of tokens. This association is how the relationship of a flow of words is established and influences the direction that the model computes. This is why a naming convention needs to be very consistent.
+### Patterns For Naming Conventions
+For this section I’m going to use the example of implementing the feature story from above:
+\`I want to create a new user and assign them to an account.
+#### The Rails Way - Conventions That Have Stood The Test of Time
+The Rails framework has lead the way with “convention over configuration” for well over a decade now. You can really feel the difference this makes in your productivity when getting started. However, once you deviate from the normal Rails conventions you’ll find that Rails can become very painful to work with. This typically happens with non-RESTful business logic being intermingled into what should only be a RESTful end-point.
+The Rails conventions would typically establish the following flow:
+1. Assuming that the `UsersController` already exists, with the standard `create` action inside of it to handle a `POST` request
+2. You (the dev) would update the allowed params to add an `account_id` parameter that would be used to allow the user to be associated to the account.
+This works perfectly for a one-to-one relationship, where one user belongs to one account. What happens if we want to make a many-to-one relationship where the user can have multiple accounts it has access to? This is where the Rails conventions can start to become murky and developers get creative in their solutions.
+You may do one of the following:
+1. You create a service object or PORO to handle the logic from the request and neatly organize the process into 1 or more classes to handle the job.
+2. You update the allowed params to make the `account_id` into an `account_ids` array that manages a join table that represents the association for the user.
+3. You split the association into 2 end-points, and you have your UI perform multiple successive requests in order to create/update all of the relationships.
+4. You stuff a bunch of logic into your controller to determine if/when updates to the joining records need to happen (most common rapid development approach).
+Depending on the maturity of your app, you may start at option 3 and move up in sophistication or simplicity. There’s no real wrong answer here, just a lot of opinions.
+Rails doesn’t have one way of handling increasingly complexity. It’s up to the developer who is writing the start of the feature to hopefully do it in a way that works right for the maturity level of the project at that time.
+However, when we introduce an AI agent into the mix the story begins to change.
+#### The Agent Enhanced Way
+Working with an AI agent can be a powerful multiplier for your efficiency as a dev, especially as the app grows in complexity. This is highly dependent on how clear the patterns are that you choose.
+The pattern that you choose is critical because it heavily influences the models train of thought. Since AI models don’t have mental models like you or I do, they become heavily influenced by the way a prompt is written. You can effectively ask the same question, word it in various ways and get the AI to provide a varying answer. This is both good and bad. It means the AI can be articulate with some level of complexity, but it creates less certainty in the consistency required for coding. We can overcome this, mostly, by using a more strict and consistent naming convention.
+Let’s start by looking at something that would generally be acceptable as “good code”.
+```crystal
+class Customer
+  property name : String
+  property email : String
+  def initialize(@name, @email)
+  end
+end
+```
+Here we have the barest of minimums that represent a Customer for our new SaaS product. After all, this entire method is around building and maintaining products as they grow in complexity.
+I am intentionally skipping persistence methods because this explanation is about naming conventions.
+Our first job is going to be setting up subscriptions for Customers. A Customer can have many Subscriptions.
+So now we have a setup like this:
+```crystal
+class Subscription
+  property name : String
+  property rate : Int16
+  property quantity : Int16
+  def initialize(@name, @rate, @quantity)
+  end
+end
+class Customer
+  property name : String
+  property email : String
+  property subscriptions : Array(Subscription) = [] of Subscription
+  def initialize(@name, @email)
+  end
+end
+```
+At this point the relationship between the two objects is clear and the names are simple and imply their intended meaning. Our minds have mental models of what a Customer is and what a Subscription is because of our life experience. We can fill in the implications of what the property and its type mean. The `name` property is relatively clear.
+However, to an AI this kind of naming is less than ideal. It will probably still work, but will progressively become less and less useful as the classes grow in complexity.
+Instead if we change to a more verbose naming convention that adds in contextual meaning, the AI is better able to understand what we are trying to do.
+Let’s focus on the Customer class first and you’ll see what I mean.
+```crystal
+class Customer
+  property first_name : String
+  property last_name : String
+  property email_address : String
+  property list_of_all_active_subscriptions : Array(Subscription) = [] of Subscription
+  def initialize(@name, @email)
+  end
+end
+```
+You may have noticed that a lot has changed and at the same time, we changed very little.
+Notice how explicit the name attributes are now? The name before could have been first, last, middle initial or full name. Who knows? We certainly didn’t have those details before. A more senior developer reading this probably picked up on that quickly!
+We’ve now expanded our `email` to `email_address` because now it’s 100% clear that we intend to store an email address there and some kind of flag that says the email subscription list that the Customer belongs to. It was implied that the value was intended to be an email address, but it’s entirely possible its intended use was not that.
+The changes to our old `subscriptions` property are a bit shocking! Did you have any idea that all you needed to track were the active subscriptions? Maybe during the conversation with a product owner, but the AI would have no idea. By updating the naming we now have a clear purpose given to that property with a contextually significant meaning.
+So far all of the examples are fairly simple and straight forward. In fact, this is already pretty close to what would be considered “good” naming practices. So let’s take this to the next level where there’s a lot more complexity. This is where real business logic becomes messy and far less non-obvious.
+Well the good news is that our little SaaS is growing up and now has more products and all new licensing. The sales team has been getting enterprise customer inquiries and the deal size is so big that the product team is now being told we need to adapt our one Customer to many Subscriptions model to allow for Customers who aggregate into a single billable entity, and prevents these users from adding any subscription items.
+By the way, you have a super short window to implement so there’s no way to take time to architect this thoroughly and perform any data migrations.
+That’s alright, this type of feature request is the Achilles Heel of many code bases. Typically in this kind of scenario we start seeing naming becoming a challenge. Let’s see how we can do it so that it benefits our AI agent assistant, or how our agent would be implementing this feature if we let it drive for us.
+```crystal
+class Customer
+  property first_name : String
+  property last_name : String
+  property email_address : String
+  property list_of_all_active_subscriptions : Array(Subscription) = [] of Subscription
+  property is_this_an_enterprise_customer : Bool
+  def initialize(@first_name, @last_name, @email_address, @is_this_an_enterprise_customer = false)
+  end
+end
+class EnterpriseCustomerBillingEntity
+  property full_legal_entity_name : String
+  property payment_terms_in_number_of_days : Int8
+  property billing_cycle_frequency : Int8
+  property billing_cycle_time_period : String
+  property maximum_customers_according_to_the_contract_limit : Int16
+  property current_count_of_customer_accounts : UInt16
+  def initialize(@full_legal_entity_name, @payment_terms_in_number_of_days, @billing_cycle_frequency, @billing_cycle_time_period, @maximum_customers_according_to_the_contract_limit, @current_count_of_customer_accounts)
+  end
+end
+```
+We now have this new class mixed in that handles the enterprise details. This isn’t about programming the full workflow, it’s about the naming convention used here. A pattern is beginning to emerge.
+Now depending on your level of seniority as a dev, you may read those class attributes and think “yeah that’s basically what I would do, except I’d simplify the names a bit”. And this is when I can begin outlining the general rules to follow when writing code you want an AI assistant to flourish with:
+1. Object attributes with primitive types should be short statements or phrases
+2. Object attributes that are booleans should be phrased as a “yes/no” question or statement
+3. Object attributes that are collections, Arrays or enumerable in some way. Usually it’s good to start the name like “list\_of\_” or “array\_of\_” with a descriptive name of the object types it’s holding.
+Following these guidelines will help keep your naming conventions consistent which helps provide clarity and contextual understanding for your AI agent. It’s also good for you, because you may come back to this code many months or years later and you will not remember the product meeting details but you can clearly read your code.
+#### Method & Variable Naming
+Next let’s discuss method and variable naming. This is the most common area where devs can help themselves greatly, but typically fall short. Clever naming can make short variable names for easier readability but the context of what and why quickly disappears into your editors background.
+We left some of the business logic that was in our new feature requirement that we can use for this part. The part we are going to focus on is going to be:
+`prevents these users from adding any subscription items`
+This is something that we can use a process manager to handle while exercising good naming conventions.
+This is a process manager, but it does not use “process” or “manager” in the name. It is acceptable with or without including those details.&#x20;
+```crystal
+class AddSubscriptionToCustomer
+  property customer_to_add_subscription_to : Customer
+  property subscription_to_add_to_customer : Subscription
+  def initialize(@customer_to_add_subscription_to, @subscription_to_add_to_customer)
+  end
+  def add_subscription_to_customer
+    return if @customer_to_add_subscription_to.is_this_an_enterprise_customer
+    @customer_to_add_subscription_to.list_of_all_active_subscriptions << subscription_to_add_to_customer
+  end
+end
+```
+1. The class name for the process manager clearly states what the entire process is attempting to do in a short statement.
+2. The initialize method accepts all of the initial data required to perform the process
+3. The name of the method to start the process is clear and obvious.&#x20;
+This reads very plainly now. The logic in the `return` line reads almost like a complete sentence. This makes the intent very clear for both you the developer and your AI agent assistant.
+The variable names clearly state what the contents are, and the intended use.
+The method name clearly states the action that is being performed. It does not take any parameters because the intended purpose of a process manager is to be initialized with all of the data it needs in order to perform the process it is managing.
+Do you come across code this plainly and clearly written? Maybe. It’s more than likely that it’s plain on that it uses simpler wording and phrasing that is less robust, but still clear. You may have seen `customer_to_update` and considered that good over just `customer`. Maybe you consider the one word better. But your AI agent is going to have less and less of a clear intent by using such simplified wording.
+### The Compounding Rewards of Enhanced Naming
+You are rewarded for clearer naming practices as your files get larger. In fact, you may start implementing these naming conventions and notice something strange. At first, your code completion suggestions from typical AI coding assistants will usually be pretty bad. Only at first, but it’s distinctly noticeable.
+Github Copilot tends to be the worst offender by offering up code snippets that are close but make silly naming mistakes when re-using existing variables. Mistakes such as pluralizing when the variable should be phrased singularly and vice-versa.
+I use Cursor, which has a Copilot++ in editor code suggestion tool and it tends to work much better. It still has lower quality suggestions initially, but as your files grow in size, the suggestions and understanding of what you are trying to do become increasingly more accurate. This includes across files when you’re using Copilot++.
+---
+*Chapter 02 of the AED canon · published **verbatim** from the author's original; the work-in-progress marker at the top is his own, kept as written · continue to [03 · Process Managers](https://github.com/AgentC-Consulting/aed-conventions/blob/v1.1.0-rc.1/03_process_managers.md) · [reading order](https://github.com/AgentC-Consulting/aed-conventions/blob/v1.1.0-rc.1/README.md#reading-order)*
+---
+<!-- source: 03_process_managers.md -->
+## Process Manager Conventions
+`_This is a work in progress_`. Updated on 11/24/2025
+Process managers are a convention that AI agents need to organize an unRESTful process. This is commonly domain specific business logic or workflows.
+A process manager name is a statement or phrase that describes what is being done.
+Let’s use an example of building a report. We are just going to describe the feature story that defines this process, and the triggering event. For this example our app has Customers:&#x20;
+`When a list of Customer ID’s is provided, then lock each customers account.`
+Processes start with a “when” keyword, always. Because a process is “when” something happens!
+The second statement “a list of Customer ID’s is provided” tells us the qualifying information we need before this process can be performed. Here were are referencing a “list” aka an Array of IDs which is the attribute type from the Customer model. This could be integers, ULID, UUID’s etc.
+The second half “lock each customers account” is using jargon that represents an operation we define for the business. “Locking” an account for this means: changing an attribute in the Customer model that requires an additional input from the user to confirm their identity and reset their password.
+A process manager can perform many operations at a time, and typically will. The more complicated the process, the more likely to require human intervention to write the complete the process writing.
+If we expand our process statement, it looks like the following:
+`When an array of Integers that represent Customer IDs is provided then loop through each Customer account using the ID to find the correct record and update the necessary attribute that will prevent the Customer from accessing their account.`
+The AI is going to analyze this and ultimately make the determination if any jargon was used, and will ask questions if it can’t understand your intent. It will generally phrase it like I explained above, and may provide more details.
+---
+*Chapter 03 of the AED canon · published **verbatim** from the author's original (last revised 2025-11-24); the work-in-progress marker at the top is his own, kept as written · continue to [04 · Feature Stories](https://github.com/AgentC-Consulting/aed-conventions/blob/v1.1.0-rc.1/04_feature_stories.md) · [reading order](https://github.com/AgentC-Consulting/aed-conventions/blob/v1.1.0-rc.1/README.md#reading-order)*
+---
+<!-- source: 04_feature_stories.md -->
+## Agent Enhanced Development - The Whole Process
+### Introduction To What A Feature Request Is
+The idea of “operating” an AI means we need to be able to define it’s “operations” to begin with.
+An operation is essentially the work flow for performing a task. This should encompass multiple steps and possibly “tasks” depending on how you want to define a task.
+To operate an AI agent successfully, we have to shift our mindset on a few topics, such as:
+1. How we define the work that we want to perform
+2. The expected patterns or overall flexibility we have in our code base
+3. Our definition of naming conventions and what "clear" means for us
+4. How we perform development work
+5. The relationship between the code we write and how it reflects the business
+To begin with, we are going to start by more clearly defining what a `feature request` really is. If you've been a developer for any period of time, you've most likely already worked with scrum or agile and been exposed to User Stories. The idea here is pretty similar, however instead of managing the details of the story from a 3rd party tool such as Jira, we are going to manage the details directly with our AI agent that works from our code base.
+Let's define some critical terminology before we move forward.
+**Operation**: the interaction with the AI agent and ensuring it has the correct knowledge and understanding to perform.
+### Our First Feature Request
+Let’s describe some default operations that should come with the framework. I have notes about user stories and I think that operating an AI development agent should mean using Feature Stories to control the behavior of the agent and the outcome.
+First a simple user story:
+`As an **Admin** user, I want to _create_ a new **user** **_and_** _assign_ them to an **account**`
+This story is pretty simple and would mean operations that are required use the typical MVC concepts, which makes things easy to start with.
+The `As an Admin` establishes our persona, scoping the following **action** to be performed. When there is a persona we have chosen, we also know the feature request requires a view and a controller action at a minimum. Our agent knows which views belong to which controller actions, and if we need to create that controller, action, view etc.
+The action is the full statement. It should be a clear summary of what would complete a request/response cycle. If it triggers or enqueues a background job, that should be stated. The action description should also include references to any data models that require a relationship. In the example that’s User and Account. The plurality of the data models dictates the relationships between them, and should use the same Active Record pattern expressions as in Rails.
+The “I want to” part is provided as part of the story builder. The action verb needs to be an HTTP verb of GET POST PUTS PATCH or DELETE followed by the primary data model that is effected.
+A unique verb of “perform” can be used to trigger a workflow that is not RESTful. This is the keyword you primarily use for our unique business logic, aka your special sauce.
+The specially called out “and” in the action is because we follow up a simple RESTful action with a secondary action, and it’s establishing a relationship with an additional record. In this case I highlighted “assign” because it’s an example of company jargon that can alias an Active Record relationship of “belongs to”. These kinds of aliases can be configured with restrictions/conditions before creating a feature story. This story implies it is limited to linking the newly created user to an existing account, and that it does not create a new account.
+A feature story with a persona breaks down it’s structure like this:
+`As a (specify persona), I want to (RESTful verb, or “perform”) (“a” or “multiple”) (data model name of an existing data model) and (AR relationship name/type or “perform”) (data model name or Process Manager name if performing a process)`
+A “persona” is a specialized alias of a User data model type that includes an indication of the “authorization” (ie permissions) level of that model type. For example, an Admin persona could be an alias of a Super Administrator type that has unrestricted permissions, which means they would be using controllers/routes that are scoped to this kind of user.
+Authorization levels work in several ways together to create a robust authorization system.
+- Model type: the model name should represent the general permission level of that group. This is resource based, so an Administrator user type may have its own API and all administrators would generally be considered to use those end-points.
+- Action specific: RESTful verbs have a matching permission level two on the actual model as an attribute. Your app configuration should define if by default the user of that group is allowed or disallowed, and if the flag necessary to perform the action needs to be specified on the models record.
+- Individual resource: individual resources can restrict behavior to model type or record ID’s.
+For unRESTful end-points, the permissions are based on if the model type or specific records of models are allowed to execute an action.
+### Breakdown of The Anatomy of A Feature Request
+TBD
+---
+*Chapter 04 of the AED canon · published **verbatim** from the author's original. The closing `TBD` is the author's own — the anatomy breakdown is genuinely unwritten, and this release candidate marks it rather than papering over it · continue to [05 · Edit-Level Style](https://github.com/AgentC-Consulting/aed-conventions/blob/v1.1.0-rc.1/05_edit_level_style.md) · [reading order](https://github.com/AgentC-Consulting/aed-conventions/blob/v1.1.0-rc.1/README.md#reading-order)*
+---
+<!-- source: CONVENTIONS.md -->
+## AED Conventions — Code That Reads Like Statements
+**Agent-Enhanced Development (AED)** is how [AgentC Consulting](https://agentc.consulting)
+writes code that both humans and coding agents can read, change, and review
+with the least friction. The guiding rule is simple:
+> **Prefer the form that reads like a plain statement of intent. Reach for
+> shorthand only when it makes the intent _clearer_, never just shorter.**
+Clever, compressed syntax saves the author a few keystrokes and costs every later
+reader (human or agent) a re-parse. In an agent-driven codebase, that trade is
+almost always wrong: the code is read and modified far more often than it is
+written. Optimize for the reader.
+These conventions are the *readability* half of the practice. Their
+*correctness* companion is edit-time verification: run the compiler's type
+check (for Crystal, the compiler frontend with `--no-codegen`) on every edited
+file so mistakes surface immediately, not minutes later in a full build. AED
+keeps the code clear; the edit-time check keeps it compiling. In our own
+tooling this runs automatically after every agent edit — wire the equivalent
+into whatever harness your agents use.
+The examples below are Crystal, because that is what we build with. The rules
+are about reading, not syntax.
+---
+### The rules (with Crystal examples)
+<a id="rule-1"></a>
+#### 1. Branch on type with an explicit `if … is_a?`, not a clever `case`
+`case … in` demands *exhaustive* matching, and in codebases using the Grant ORM
+it trips over Grant's `Grant::Base+` type inference (`Error: case is not
+exhaustive. Missing types: Grant::Base`). `case … when .is_a?(T)` (the
+dot-receiver sugar) compiles but reads like a puzzle. An ordinary `if` reads
+like a sentence.
+```crystal
+# ✅ AED — reads like a statement
+if user.is_a?(Users::Regular)
+  session[:user_type] = "regular"
+  session[:session_version] = user.session_version
+else
+  session[:user_type] = "admin"
+end
+# 🚫 trips Grant inference AND hides intent
+case user
+in Users::Regular then ...
+in Users::Admin   then ...
+end
+# 🚫 compiles, but the leading dot is a riddle
+case user
+when .is_a?(Users::Regular) then ...
+end
+```
+<a id="rule-2"></a>
+#### 2. Name the thing; don't make the reader decode a chain
+```crystal
+# ✅ AED
+expected_state = session["oauth_state"]?
+return unless expected_state && constant_time_equal?(expected_state, state)
+# 🚫 terse, but the reader has to hold three operations in their head
+return unless session["oauth_state"]?.try { |s| constant_time_equal?(s, state) }
+```
+<a id="rule-3"></a>
+#### 3. Prefer explicit guard clauses to nested ternaries / one-liners
+```crystal
+# ✅ AED
+return nil if password_digest.empty?
+return nil unless Crypto::Bcrypt::Password.new(password_digest).verify(password)
+self
+# 🚫 dense
+password_digest.empty? ? nil : (Crypto::Bcrypt::Password.new(password_digest).verify(password) ? self : nil)
+```
+<a id="rule-4"></a>
+#### 4. Use full, intention-revealing names
+Methods and locals are sentences-in-miniature: `establish_session`,
+`invalidate_all_sessions`, `find_or_create_from_oauth`, `expected_state`. Avoid
+`do_it`, `tmp`, `x`, `res2`. A good name removes the need for a comment.
+<a id="rule-5"></a>
+#### 5. Say *why* in a comment, let the code say *what*
+Comments earn their place by explaining intent, security rationale, or a
+non-obvious constraint — not by restating the line. The house style: a
+session-establishing method carries a comment stating the fixation attack it
+prevents; an encrypted column carries a comment stating what the encryption
+protects and why. If a comment could be deleted with no loss because the code
+already says it, delete it.
+<a id="rule-6"></a>
+#### 6. One statement per line; let the formatter own the layout
+Run `crystal tool format` (or your language's canonical formatter) as part of
+every edit. Canonical formatting means every reader and every diff sees the
+same shape.
+---
+<a id="shorthand-boundary"></a>
+### When shorthand IS the clearer form
+AED is "clarity first," not "verbose always." Idioms that are *more* readable are
+encouraged: `arr.map(&.name)`, `value.try(&.to_i64?)`, a `?`-suffixed predicate,
+a single well-named guard expression. The test is always: **does a reader who has
+never seen this code understand the intent on first pass?** If yes, keep it. If
+they have to mentally execute it, expand it.
+---
+<a id="checklist"></a>
+### Checklist before you finish an edit
+- [ ] Type branches use explicit `if … is_a?` (not `case … in` against Grant types).
+- [ ] No one-liner hides more than one operation from the reader.
+- [ ] Names state intent; no `tmp`/`x`/`res2`.
+- [ ] Comments explain *why*, never restate *what*.
+- [ ] `crystal tool format` is clean.
+- [ ] The edit-time type check passed (no `case is not exhaustive`, no undefined methods).
+---
+### Status and versioning
+This document is the public canon of the AED conventions, versioned by signed
+git tags. Rules covering control flow (loops, guards, rescues, fibers, macros)
+are drafted and under internal review; they will land here as a tagged minor
+version. The [ADOPTION.md](https://github.com/AgentC-Consulting/aed-conventions/blob/v1.1.0-rc.1/ADOPTION.md) log records, with dates, when each rule
+entered practice and when it was published.
+---
+<!-- source: 06_control_flow.md -->
+## 06 · Control Flow (CF-1 … CF-11)
+> **Status**: RELEASE CANDIDATE. These eleven rules ship in `v1.1.0-rc.1` as a
+> candidate, not as settled canon. The numbered questions at the end are still
+> open, and the answers may change individual thresholds before `v1.1.0` final.
+> Adopt them if they help; expect the edges to move.
+>
+> **Scope question answered here**: how should AED handle control-flow code
+> whose *syntax* does not naturally align with the reads-like-statements rule?
+> A `while` loop, a `rescue` ladder, or a `spawn` block has no name of its own
+> — the syntax is pure mechanism. AED's answer, developed rule by rule below:
+> **when the syntax can't read like a statement, the *names around it* must
+> say what the syntax is doing.**
+---
+### 0. Census — what actually occurs in our Crystal
+Rules should target real frequency, not theory. Counted with `grep -rE`
+across the two live codebases (regex counts are ceilings — e.g. the ternary
+pattern also matches nilable type signatures; noted where it matters):
+| Pattern | premium template `src/` (107 files, 12,250 lines) | agentc_website `src/` (22 files, 2,163 lines) |
+|---|---:|---:|
+| Leading `if` | 154 | 23 |
+| `if … is_a?` (existing Rule 1) | 6 | 0 |
+| `case` statements | 28 | 3 |
+| `when` branches | 124 | 6 |
+| `case … in` | **0** | **0** |
+| Leading `unless` | 25 | 5 |
+| Any ` unless ` (incl. postfix) | 150 | 24 |
+| `while` | 4 | 8 |
+| `until` | **0** | **0** |
+| `loop do` | 2 | 0 |
+| `break` | 3 | 12 |
+| `next` | 15 | 3 |
+| `return` (all) | 127 | 43 |
+| Guard `return … if` | 36 | 19 |
+| Guard `return … unless` | 58 | 7 |
+| Ternary `? … :` (regex ceiling; true ternaries ≈ half) | 61 | 16 |
+| `begin` | 14 | 2 |
+| `rescue` | 57 | 8 |
+| `ensure` | 13 | 0 |
+| `retry` | **0** | **0** |
+| `raise` | 156 (138 typed error, 14 bare string) | 1 |
+| `spawn` | 4 (2 real code sites) | 0 |
+| `Channel` | 1 | 0 |
+| Concurrency `select` | **0** | **0** |
+| `.each` | 16 | 7 |
+| `.map` | 30 | 5 |
+| `.select`/`.reject` | 13 | 4 |
+| `.try` | 98 | 3 |
+| `&.` shorthand | 116 | 7 |
+| `macro` definitions | 3 | 0 |
+| `{% if %}` compile-time branches | 2 | 0 |
+| `def …?` predicate methods | 195 | 26 |
+| `def …!` bang methods | 10 | 0 |
+**What the census says:**
+- The codebase already leans AED: guard returns (120 across both repos) far
+  outnumber loops (14); typed raises outnumber string raises 10:1; there are
+  195 `?` predicates in the template — the "name the question" culture exists.
+- `case … in`, `until`, `retry`, and concurrency `select` occur **zero**
+  times. We can codify their status cheaply — banning what nobody uses costs
+  nothing and stops an agent from introducing them.
+- The high-frequency gaps that need real rules: `case/when` menus (28+3
+  sites), guard ordering (120 guard returns with no stated ordering rule),
+  `unless` (175 total uses, some compound), `.try` (98 uses — the single
+  biggest "decode a chain" risk), and bare `rescue` (a large share of the 65
+  rescues carry no error name).
+- The website's markdown parser is a legitimate **cursor-loop** cluster
+  (8 `while` + 12 `break` in one file family) — the loop rule must bless that
+  shape, not fight it.
+---
+### The core insight: mechanism syntax vs statement syntax
+The existing skill's rule — *prefer the form that reads like a plain statement
+of intent* — works effortlessly for **expressions**: you pick the spelling
+that reads best. Control flow is different. `while`, `rescue`, `spawn`,
+`{% if %}` are **mechanism keywords**: they say *how* execution moves, never
+*why*. No amount of re-spelling makes `while @i < @lines.size` state an
+intent.
+So for control flow, AED shifts from "pick the readable spelling" to three
+compensating moves, in priority order:
+1. **Name the intent next to the mechanism** — the condition is a named
+   predicate, the body is a named method, the error is a named type, the
+   fiber does a named job.
+2. **Keep the mechanism in one canonical shape** — one blessed way to write
+   each construct, so a reader (or a linting hook) recognizes it instantly.
+3. **Ban the shapes that only ever obscure** — the census shows we already
+   live without them.
+Every rule below is one of those three moves. Format per rule: (a) why the
+raw syntax fights the reading rule, (b) the proposed rule with a crisp name,
+(c) before/after in the skill's voice, (d) the honest cost, (e) the
+mechanical check an agent, linter, or hook can apply.
+---
+### Rule CF-1. `case` is a menu — every branch one bite
+**(a) Why the syntax fights the rule.** A `case` on a *value* (`case action`,
+`case fmt`, `case status_code`) is actually the closest control flow gets to
+a plain statement — *"depending on the action: …"*. It stops reading like a
+statement in exactly two ways: when a branch body grows into a paragraph (the
+reader loses the menu and falls into one dish), and when the subject is an
+expression the reader must evaluate first (`case ENV["AI_DEFAULT_PROVIDER"]?.to_s.downcase`).
+**(b) Proposed rule — "Case is a menu, not a novel."**
+Use `case … when` when branching a **single named value** across **three or
+more** outcomes. Two outcomes is an `if/else` (a menu of two is just a
+choice). Each `when` body is at most ~3 lines or a single named method call —
+if a branch needs a paragraph, extract it to a method whose name is the
+branch's intent. The `case` subject must be a **named local or a plain
+method call**, never an inline expression chain. Always write an explicit
+`else` that states the fallback (`false`, `raise`, or a named default) —
+Crystal's `when` is not exhaustive, so the `else` is where you *say* what
+happens to the unlisted world. `case … in` stays banned per existing Rule 1
+(census: zero uses — nothing to migrate).
+**(c) Before/after.**
+```crystal
+# ✅ AED — a menu: named subject, one bite per branch, spoken fallback
+default_provider = ENV["AI_DEFAULT_PROVIDER"]?.to_s.downcase
+case default_provider
+when "anthropic" then Anthropic::Client.new
+when "openai"    then OpenAI::Client.new
+else                  raise "Unknown AI_DEFAULT_PROVIDER: #{default_provider}"
+end
+# 🚫 subject is a puzzle the reader must evaluate before the menu even starts
+case ENV["AI_DEFAULT_PROVIDER"]?.to_s.downcase
+when "anthropic" then ...
+end
+# 🚫 a two-item "menu" — this is just an if wearing a costume
+case backend
+when :smtp then deliver_smtp(message)
+else            deliver_log(message)
+end
+# ✅ instead:
+if backend == :smtp
+  deliver_smtp(message)
+else
+  deliver_log(message)
+end
+```
+The policy classes are the house exemplar already
+(`src/policies/team_policy.cr`): `case action` with one-line branches
+composed of `?` predicates (`team_lead? || admin_access?`) and `else false`.
+That file reads like an access-control table — which is the point.
+**(d) Cost.** Extracting fat branches adds methods; a reader who wants the
+details takes one hop. Two-branch `case` fans will find the if/else rule
+fussy. Accepted: the menu shape is only worth its visual weight when there is
+an actual menu.
+**(e) Mechanical check.** Flag: `case` whose subject line contains `.` more
+than once or any `?.`/`ENV[`; any `when` body exceeding 3 lines; any `case`
+with fewer than 3 `when` branches; any `case` without `else`; any `case … in`
+(already caught by the compile hook on Grant types — extend to a grep ban).
+---
+### Rule CF-2. Loops state their finish line
+**(a) Why the syntax fights the rule.** `while` states a *continuation
+condition*, but a reader thinks in terms of a *finish line* ("keep going
+until the lines run out"). Worse, `loop do … break` scatters the finish line
+into the body, and an index cursor (`@i`) makes progress invisible — the
+reader must verify the loop advances or they can't trust it terminates.
+**(b) Proposed rule — "Every loop names its finish line and shows its
+step."** Three blessed loop shapes, nothing else:
+1. **Collection walk** — `items.each do |item|` (default; covers most needs).
+2. **Cursor loop** — `while cursor_has_more?` over an explicit cursor, where
+   (i) the condition is a plain comparison or a named `?` predicate, (ii)
+   every `break` inside is a one-line guard whose condition is a named
+   predicate or plain comparison, and (iii) the cursor visibly advances in
+   the body (an `@i += n` a reader can point at). This blesses the website's
+   markdown parser shape (`while @i < @lines.size` … `break unless row?(s)` —
+   `article_markdown.cr` already complies, its break conditions are named
+   predicates like `ordered_item?`, `task_item?`, `row?`).
+3. **Forever loop** — `loop do` only for intentionally unbounded work (the
+   SSE heartbeat in `mcp_sse_controller.cr`), and it must sit inside a method
+   whose **name says it loops** (`run_heartbeat_loop`, `pump_stdout`), with
+   its exit spelled as a guard (`break if client_disconnected?`).
+If a loop body exceeds ~8 lines, extract the body to a method named for one
+iteration's intent (`consume_blockquote`, `emit_table_row`) — the loop line
+then reads *"while there are lines, consume the next block."*
+`until` is **banned** (census: zero uses): `until done?` forces the reader to
+negate in their head; write `while more?`.
+**(c) Before/after.**
+```crystal
+# ✅ AED — cursor loop: named finish line, named break, visible step
+while @i < @lines.size
+  line = @lines[@i].strip
+  break unless ordered_item?(line)
+  emit_ordered_item(line)
+  @i += 1
+end
+# 🚫 the finish line is a negation the reader must invert
+until @i >= @lines.size
+  ...
+end
+# 🚫 forever-loop with an anonymous job and a buried exit
+loop do
+  sleep 15.seconds
+  begin
+    send_event(response, "ping", {time: Time.utc.to_unix})
+  rescue
+    break
+  end
+end
+# ✅ instead: the method name carries the loop's intent
+private def run_heartbeat_loop(response) : Nil
+  loop do
+    sleep 15.seconds
+    break unless send_ping(response) # returns false when the client is gone
+  end
+end
+```
+**(d) Cost.** Extraction adds one hop per fat loop; the "visible step" rule
+occasionally forces an `@i += 1` where a cleverer restructure could avoid the
+cursor entirely. Accepted: termination you can point at beats elegance you
+must simulate.
+**(e) Mechanical check.** Flag: any `until`; any `loop do` in a method whose
+name lacks `loop`/`pump`/`watch`/`poll`; any `while` body > 8 lines; any
+`break` followed by a compound condition (`&&`/`||` on the same line); a
+`while i <`-style loop whose body never reassigns the cursor variable.
+---
+### Rule CF-3. Guards are the bouncer — they stand at the door
+**(a) Why the syntax fights the rule.** An early `return` is invisible in
+prose: a non-technical reader scanning top-to-bottom doesn't naturally know
+that `return nil unless key` means *everything below assumes a key exists*.
+Guards scattered mid-method are worse — the story keeps getting interrupted
+by exits the reader has to fold into their mental state.
+**(b) Proposed rule — "Guards first, story second."** Guard clauses (already
+the house majority style — 120 guard returns across both repos, and existing
+Rule 3 prefers them) get an *ordering and shape* contract:
+- All precondition guards sit in a **contiguous block at the top** of the
+  method, before the first line of the happy path. A reader — technical or
+  not — reads them as a doorman's checklist: *"no ticket, no entry; wrong
+  tag, no entry."* Everything after the blank line is the story with all
+  assumptions established.
+- One guard per line, one idea per guard. A guard's condition is a plain
+  comparison, a named predicate, or a single nil-check — never a compound
+  needing parentheses (extract to a `?` method, see CF-8).
+- A `return` *after* the story has started is allowed only when it is the
+  method's **answer** (the natural end of a branch), not a late-discovered
+  precondition. If you discover a precondition mid-story, either hoist it or
+  extract the remainder into a method with its own door.
+- Guards that reject for a *reason worth documenting* say why on the line
+  above (`# CSRF: state must match what we issued`), per existing Rule 5.
+`src/wire/cose.cr` is the exemplar: five `return nil unless …` guards in a
+row, then the single decrypt statement — the shape *is* the security
+argument.
+**(c) Before/after.**
+```crystal
+# ✅ AED — the bouncer's checklist, then the story
+def verify_password(password : String) : self?
+  return nil if password_digest.empty?
+  return nil unless Crypto::Bcrypt::Password.new(password_digest).verify(password)
+  self
+end
+# 🚫 nested ifs — the reader carries open questions to the last line
+def verify_password(password : String) : self?
+  unless password_digest.empty?
+    if Crypto::Bcrypt::Password.new(password_digest).verify(password)
+      self
+    end
+  end
+end
+# 🚫 a precondition ambushing the reader mid-story
+def publish(article)
+  html = render(article)
+  return if article.draft?   # ← this belonged at the door
+  upload(html)
+end
+```
+**(d) Cost.** Hoisting sometimes evaluates a guard slightly earlier than
+strictly needed (rarely matters; note it when it does). Multiple exit points
+still bother single-exit purists — AED sides with the checklist reader.
+**(e) Mechanical check.** Flag: a `return … if/unless` guard appearing after
+the first non-guard, non-comment statement of a method (heuristic: guard
+lines must be a prefix of the method body); any guard condition containing
+`&&`/`||` (send to CF-8); nesting depth > 2 inside a method that has no
+guards (suggests inversion is available).
+---
+### Rule CF-4. `unless` carries one positive idea
+**(a) Why the syntax fights the rule.** `unless` reads beautifully as an
+English exception — *"return nil unless the state matches"* — right up until
+the condition contains logic. `unless a && b` requires De Morgan in the
+reader's head ("so it runs when… a is false, OR b is false…"). The census
+shows 175 total `unless` uses; most are clean guards, but sites like
+`unless key.algorithm == ES256 && key.curve == P256` (`webauthn/verifier.cr`)
+cross the line.
+**(b) Proposed rule — "`unless` takes one idea."**
+`unless` (postfix or block) may wrap **one positive condition**: a single
+predicate call, a single comparison, or a single presence check. Never
+`unless` with `&&`, `||`, or `!`; never `unless … else` (Crystal allows it;
+AED bans it outright — an inverted two-branch is an `if` written backwards).
+Compound conditions get a named `?` predicate first, then `unless` may carry
+the name. `until` is covered (banned) by CF-2 — same negation tax.
+**(c) Before/after.**
+```crystal
+# ✅ AED — name the compound, then the exception reads like English
+def es256_key?(key) : Bool
+  key.algorithm == COSE::Algorithm::ES256 && key.curve == COSE::EC2Curve::P256
+end
+raise Error.new("expected an ES256 key") unless es256_key?(key)
+# 🚫 the reader must run De Morgan to know when this fires
+unless key.algorithm == COSE::Algorithm::ES256 && key.curve == COSE::EC2Curve::P256
+  raise Error.new("expected an ES256 key")
+end
+# 🚫 unless/else — an if, written in a mirror
+unless info.email_verified
+  reject_signup
+else
+  create_account
+end
+```
+**(d) Cost.** One extra tiny method per compound; occasionally a predicate
+used exactly once. Accepted: the predicate name doubles as documentation and
+as a doc heading (see §Docs).
+**(e) Mechanical check.** Flag: `unless` on a line containing `&&`, `||`, or
+` !`; any `unless … else`; any `until`. All three are plain greps — ideal
+hook material.
+---
+### Rule CF-5. Ternary picks between two spellings of one value
+**(a) Why the syntax fights the rule.** A ternary compresses a branch into a
+breath. That's fine when both arms are *values of the same idea*
+(`success ? "info" : "warning"`), because the reader parses it as one noun
+with two spellings. It fights the rule the moment an arm contains a call
+with effects, another `?`, or the arms are different *actions* — then the
+reader is executing code inside a noun slot.
+**(b) Proposed rule — "Ternary is a value with two spellings, and it gets a
+name."** A ternary is allowed only when **all** hold: both arms are simple
+values (literal, variable, or a single pure call); no nesting; no side
+effects; and the result is immediately **named** — assigned to a variable or
+passed as a named/keyword argument whose name states what it is. Choosing
+between two *actions* is always an `if/else`. Existing Rule 3's ban on
+nested ternaries is subsumed here.
+**(c) Before/after.**
+```crystal
+# ✅ AED — one noun, two spellings, and the noun is named at the call site
+severity: success ? "info" : "warning",
+# ✅ AED — named result
+byte_length = curve == OKPCurve::Ed25519 ? 32 : 57
+# 🚫 two different actions crammed into a noun slot
+logged_in? ? render_dashboard : redirect_to_login
+# 🚫 arms with their own lookups and fallbacks (real shape from icon_component.cr)
+path = name ? (ICONS[name]? || "") : (@attributes["path"]? || "")
+# ✅ instead: the branch is a decision — write it as one
+if name
+  path = ICONS[name]? || ""
+else
+  path = @attributes["path"]? || ""
+end
+```
+**(d) Cost.** Some three-line `if`s where a one-liner "worked". Accepted:
+the one-liner worked for the author; the `if` works for the reader.
+**(e) Mechanical check.** Flag: a line matching the ternary shape that also
+contains a second `?`-operator (nesting), a `!`-suffixed call, `<<`, `=`
+inside an arm, or arms containing `(…)` with further calls; ternaries whose
+result is not assigned or passed as an argument.
+---
+### Rule CF-6. Chains read like a sentence or get named waypoints
+**(a) Why the syntax fights the rule.** `users.select(&.active?).map(&.email)`
+*is* a sentence — "take the active users' emails." The syntax stops
+cooperating when a link needs a multi-line block, when a `.try` hides a nil
+branch mid-chain, or when link three depends on remembering what link one
+produced. At that point the chain is a pipeline the reader must trace, not a
+sentence they can hear. The census makes `.try` the sharpest instance: 98
+uses in the template, many nested (`data["mail"]?.try(&.as_s) || …`), versus
+only ~50 collection-chain links total.
+**(b) Proposed rule — "Two links spoken, three links named."**
+- A chain may have up to **two transformation links**, each in `&.method`
+  shorthand, when it reads aloud as one sentence.
+- Three or more links, or **any** multi-line `do … end` block mid-chain, or
+  any link whose output type isn't obvious from its name → break the chain
+  with **named waypoints**: intermediate variables named for *what the data
+  is at that point* (`active_users`, `member_emails`), not for the operation
+  (`filtered`, `mapped`, `result2`).
+- `.each` (side effects) never follows transformation links in the same
+  chain — name the collection first, then iterate it. A reader distinguishes
+  "computing" from "doing" by the line break.
+- `.try` chains: **one `.try` maximum per expression**, and only the
+  `&.method` shorthand form. Two `.try`s, a `.try` with a block containing
+  logic, or `.try` feeding `||` feeding `.try` → rewrite as an explicit
+  nil-check guard or an `if value = expr` assignment-condition. (This
+  restates existing Rule 2 with a hard threshold.)
+**(c) Before/after.**
+```crystal
+# ✅ AED — two links, one sentence
+member_emails = users.select(&.active?).map(&.email)
+# ✅ AED — waypoints named for what the data IS
+oauth_accounts   = accounts.select(&.oauth?)
+verified_emails  = oauth_accounts.map(&.email).select(&.verified?)
+verified_emails.each { |email| enqueue_welcome(email) }
+# 🚫 the reader holds three intermediate shapes in their head, then side-effects
+accounts.select(&.oauth?).map(&.email).select(&.verified?).each { |e| enqueue_welcome(e) }
+# 🚫 nested try-fallback — three nil-branches hidden in one line (real shape, microsoft.cr)
+email = data["mail"]?.try(&.as_s) || data["userPrincipalName"]?.try(&.as_s) || ""
+# ✅ instead: each source named, the preference order visible as lines
+primary_email  = data["mail"]?.try(&.as_s)
+fallback_email = data["userPrincipalName"]?.try(&.as_s)
+email = primary_email || fallback_email || ""
+```
+**(d) Cost.** More lines and more locals; hot paths allocate an intermediate
+array per waypoint (if profiling ever shows it matters, note the exception
+with a *why* comment per existing Rule 5). Accepted: this codebase reads far
+more than it iterates.
+**(e) Mechanical check.** Flag: ≥3 `.method(` / `&.` links on one expression;
+`.each` preceded by `.map`/`.select`/`.reject` in the same statement; ≥2
+`.try` in one expression; `.try do` block form; waypoint variables named
+`result`, `tmp`, `filtered`, `x2` (existing Rule 4's list, extended).
+---
+### Rule CF-7. Errors are vocabulary; rescues say what they forgive
+**(a) Why the syntax fights the rule.** `begin/rescue` reads like nothing at
+all: a bare `rescue` is the statement *"if anything whatsoever goes wrong,
+do this"* — which is almost never what the author meant and never what the
+reader can verify. Exception flow is invisible control flow: the jump happens
+on a line the reader can't see. The only way it reads like a statement is if
+the **error type carries the sentence**. The census shows the raising side
+already speaks: 138 typed raises vs 14 string raises, and a real error
+vocabulary exists (`WebAuthn::Registration::UnsupportedAttestation`,
+`Storage::FileNotFoundError`, `Authorization::…`). The rescuing side lags:
+a large share of the 65 rescues are bare.
+**(b) Proposed rule — "Raise nouns, rescue by name."**
+- **Raising**: always a typed error from the domain vocabulary; new failure
+  modes mint a new subclass under the module's base `Error` (the house
+  pattern: `class Error < Exception` per module, specific subclasses under
+  it). A bare `raise "string"` is allowed only for
+  configuration-impossible states at boot (`"ANTHROPIC_API_KEY required"`).
+- **Rescuing**: `rescue ex : SpecificError` naming the narrowest type that
+  states what you forgive. A broad `rescue ex` is permitted only at
+  **boundaries** — the outermost edge of a request, a fiber, a mailer
+  delivery, a worker — and must (i) bind `ex`, (ii) log or report it, and
+  (iii) carry a *why* comment stating the boundary ("mailer must never take
+  the request down with it"). A bare `rescue` with no binding and no comment
+  is banned.
+- **Postfix `rescue nil`** only around a *single parse/convert expression*
+  where nil is the honest answer (`Time.parse_rfc2822(date) rescue nil` —
+  the two existing uses both qualify). Never around a call with side effects.
+- **`ensure`** is for cleanup only (close, unlink, reset) — never business
+  logic; if an `ensure` grows past ~3 lines, extract it to a named cleanup
+  method (`ensure … close_worker_pipes`).
+- **`retry`** (census: zero) is banned in its raw form; retrying is a policy,
+  so it must live in a method named for it (`with_retries(attempts: 3) do`)
+  that owns the counter and backoff — a raw `retry` is an unbounded loop
+  wearing an exception costume.
+**(c) Before/after.**
+```crystal
+# ✅ AED — the rescue states exactly what it forgives, and why
+def find_verified(token : String) : Users::Regular?
+  payload = decode_session_token(token)
+  Users::Regular.find(payload.user_id)
+rescue JWT::ExpiredSignatureError
+  # Expired session is a normal event, not an error: the caller re-authenticates.
+  nil
+end
+# 🚫 forgives everything — a typo in decode_session_token now returns nil forever
+def find_verified(token : String) : Users::Regular?
+  Users::Regular.find(decode_session_token(token).user_id)
+rescue
+  nil
+end
+# ✅ AED — broad rescue earns its breadth at a boundary, with the why on record
+spawn do
+  run_heartbeat_loop(response)
+rescue ex
+  # Boundary: a dead client must never crash the server fiber pool.
+  Log.warn(exception: ex) { "SSE heartbeat fiber exited" }
+end
+```
+**(d) Cost.** Naming narrow error types takes real thought (what *can* this
+raise?), and Crystal won't tell you — there are no checked exceptions.
+Sometimes you'll name two types where a bare rescue was one word. Accepted:
+that thought is precisely the documentation the next agent needs; a bare
+rescue is a claim of omniscience.
+**(e) Mechanical check.** Flag: `rescue` at end-of-line or `rescue$` with no
+type and no `ex` binding; `rescue ex` (untyped) with no comment within 2
+lines; `raise "` outside `config/`/boot files; any `retry` keyword; `ensure`
+blocks > 3 lines; postfix `rescue nil` on a line containing `save`/`create`/
+`delete`/`<<`/`=` (side-effect heuristic).
+---
+### Rule CF-8. Three ands make a question method
+**(a) Why the syntax fights the rule.** Boolean operators are the one place
+where "statement-like" degrades *gradually*: `a && b` still reads, `a && b || c && !d`
+is a logic puzzle. The reader shouldn't need parentheses skills to know when
+a branch fires. The template's 195 `?` methods prove the extraction habit
+exists — this rule just fixes the threshold.
+**(b) Proposed rule — "Two operators is a sentence; three is a method."**
+A condition (in `if`, `unless`, `while`, a guard, or a ternary) may contain
+at most **two** boolean operators, and never a *mix* of `&&` and `||`
+without extraction — a mix means precedence, and precedence means the
+reader is parsing, not reading. Beyond that, extract either a **`?` question
+method** (when the concept recurs or belongs to the object:
+`team_lead?`, `es256_key?`) or a **named `Bool` local** (when it's one-off
+and built from locals: `state_matches = …`). The name must be the *positive*
+form of the question — no `not_invalid?`.
+**(c) Before/after.**
+```crystal
+# ✅ AED — the condition IS the sentence
+if oauth_callback_valid?(provider, expected_state, state, code)
+  ...
+private def oauth_callback_valid?(provider, expected_state, state, code) : Bool
+  return false unless provider && expected_state && state && code
+  constant_time_equal?(expected_state, state)
+end
+# 🚫 four conditions and a continuation line — a parser test, not a sentence
+unless provider && expected_state && state && code &&
+       constant_time_equal?(expected_state, state)
+  ...
+# ✅ AED — mixed operators earn a named local even at only three terms
+signature_acceptable = algorithm.rs? || algorithm.ps?
+return unless signature_acceptable && key_present?
+```
+**(d) Cost.** Method count grows; a hostile reviewer can call `?` methods
+"indirection". Accepted — with one honest caveat: the extracted name must
+truly summarize, or you've hidden the puzzle behind a label. Bad name = worse
+than inline. Naming quality falls to existing Rule 4.
+**(e) Mechanical check.** Flag: any condition line with ≥3 of (`&&`, `||`);
+any condition mixing `&&` and `||`; any `if`/`unless`/`while` condition
+spilling to a continuation line; predicate names starting `not_`/`no_`.
+---
+### Rule CF-9. Every fiber gets a job title
+**(a) Why the syntax fights the rule.** Concurrency breaks the deepest
+assumption of statement-reading: that the next line happens next. `spawn do`
+means "meanwhile, elsewhere" — and an anonymous block gives the reader no
+noun to hold on to while the main story continues. Channels are worse:
+`ch.receive` is a sentence missing its subject (*receive what, from whom?*).
+The census says our exposure is small (4 spawns, 1 channel, 0 `select`) but
+the two real sites (`isolated_worker.cr`, `mcp_sse_controller.cr`) are
+exactly the hardest code in the template — small count, maximal reader risk.
+**(b) Proposed rule — "Meanwhile, the *named* worker does its *named* job."**
+- Every `spawn` body is a **single call to a named method** whose name is
+  the fiber's job (`spawn { pump_input_to_child(in_writer, input, writer_done) }`,
+  `spawn { run_heartbeat_loop(response) }`). Never an inline multi-line
+  block: the reader should meet a fiber the way they meet an employee — by
+  title — and only read the job description if they choose to. Crystal's
+  `spawn(name: "heartbeat")` is encouraged in addition (it labels runtime
+  diagnostics) but the method name is the load-bearing part.
+- Every `Channel` variable is named for its **cargo and direction**
+  (`writer_done`, `parsed_events`, `shutdown_requested`) — the existing
+  `writer_done = Channel(Exception?).new(1)` is the exemplar. Bare `ch`
+  banned.
+- A `.receive` reads as *"wait for the writer to be done"* only if the line
+  says so: `writer_error = writer_done.receive`.
+- Concurrency `select` (census: zero): when it arrives, each branch must be
+  a one-line guard-style clause calling a named method — same menu
+  discipline as CF-1.
+- Every fiber body's outermost layer is a boundary rescue per CF-7 — a fiber
+  that dies silently is control flow the reader can never follow.
+*How a statement-reader follows concurrent flow under this rule:* the main
+story reads linearly and each `spawn` line reads as a one-sentence aside —
+"meanwhile, pump input to the child" — and each `receive` reads as
+"wait here for X." The reader never has to interleave two instruction
+streams; they follow one story with named waypoints where the streams touch.
+**(c) Before/after.**
+```crystal
+# ✅ AED — the aside has a title; the join point says what it waits for
+writer_done = Channel(Exception?).new(1)
+spawn { pump_input_to_child(in_writer, input, writer_done) }
+output = drain_child_output(out_reader)
+writer_error = writer_done.receive
+# 🚫 an anonymous ten-line meanwhile — the reader must simulate two timelines at once
+writer_done = Channel(Exception?).new(1)
+spawn do
+  begin
+    in_writer.write(input) unless input.empty?
+    err = nil
+  rescue ex
+    err = ex
+  ensure
+    in_writer.close
+    writer_done.send(err)
+  end
+end
+```
+**(d) Cost.** Method extraction can force explicit parameter passing where a
+closure captured silently — that's several extra tokens per fiber, and
+occasionally a small struct to carry them. Accepted eagerly: silent capture
+is precisely what makes concurrent code unreadable (and, per the `gc_arena`
+warnings, unsafe — a named method's parameter list *is* the audit of what
+the fiber touches).
+**(e) Mechanical check.** Flag: `spawn do`/`spawn {` whose body exceeds 1
+statement; channel locals named `ch`/`chan`/`c`; a `spawn` whose body lacks
+a rescue and whose called method lacks one (approximate: warn on every spawn,
+require the boundary-rescue comment to silence); any `select` branch longer
+than one line.
+---
+### Rule CF-10. `?` asks, `!` warns — and the suffix is a promise
+**(a) Why the syntax fights the rule.** The suffixes are Crystal's built-in
+statement-reading aid — `verified?` reads as a question, `save!` as a
+warning — but only if they're *reliable*. A `?` method returning a `String?`
+"sometimes-value" instead of a `Bool`, or a `!` method that's merely "the
+other version", breaks the reader's trained reflex and silently poisons
+every future read. Census: 195 `?` defs and 10 `!` defs in the template —
+the reflex is trainable; the contract just needs writing down.
+**(b) Proposed rule — "The suffix is a promise."**
+- `def foo?` returns `Bool` — full stop — with one blessed exception: the
+  Crystal-stdlib **maybe-lookup** convention (`session["oauth_state"]?`,
+  `ENV["KEY"]?`, `find_by?`) where `?` means *nil instead of raising*. Both
+  are questions ("is it?" / "is it there?"); nothing else earns the mark.
+- `def foo!` means **raises where `foo` returns nil, or mutates the
+  receiver** — the two Ruby/Crystal senses — and every `!` method's doc
+  comment states *which* danger it warns about, in one line.
+- In conditions, prefer the `?` form over comparison chains
+  (`user.verified?` not `user.verified_at != nil`).
+- Chaining: a `!` call never appears mid-chain (`fetch!.parse.render` hides
+  the raise in the middle of a sentence — the raise belongs on its own
+  line, where a guard or rescue can be seen next to it). A `?` predicate
+  never has its result chained onward (`valid?.to_s` is a smell: a question
+  answers, it doesn't pipeline).
+**(c) Before/after.**
+```crystal
+# ✅ AED — the question mark tells the truth
+def team_member? : Bool
+  @context.try(&.team_membership) != nil
+end
+# 🚫 a "question" that answers with a maybe-string — the reflex is now poisoned
+def admin_role?
+  membership.role if membership.admin?
+end
+# ✅ AED — the raise stands on its own line where the reader can see it
+document = Document.find!(document_id) # raises Grant::Querying::NotFound
+render(document)
+# 🚫 the raise hides mid-sentence
+render(Document.find!(document_id).with_sections)
+```
+**(d) Cost.** The maybe-lookup exception means `?` is *two* promises, not
+one — genuinely a wart, but it's stdlib-load-bearing (98 `.try`s and every
+`[]?` depend on it), so we document it rather than fight it. Some `!`
+doc-comment ceremony.
+**(e) Mechanical check.** Flag: `def …?` with a declared return type other
+than `Bool` outside index/find/lookup names; `def …!` with no doc comment;
+`!`-suffixed call followed by `.` on the same line; `?`-suffixed predicate
+call followed by `.` (excluding `[]?`/`find_by?`-style lookups).
+---
+### Rule CF-11. Macros write code; they don't hide flow
+**(a) Why the syntax fights the rule.** `{% if flag?(:preview_mt) %}` is
+control flow the runtime reader *cannot see executing at all* — the branch
+was taken at compile time, and half the file's text is a ghost. `macro
+included` generates methods that exist nowhere in the source a reader greps.
+Both defeat statement-reading not by being dense but by being **invisible**.
+Census: 3 macro defs, 2 compile-time ifs — rare, so the rule is a fence, not
+a renovation.
+**(b) Proposed rule — "Compile-time branches speak for both worlds."**
+- `{% if %}` / `{% else %}` is allowed only for **platform/flag gating**
+  (`flag?(:preview_mt)`, `flag?(:gc_agentc)`), placed at the **top level of
+  a method or file section** — never interleaved inside a runtime `if`
+  ladder. Each branch's first line is a comment stating which world this is
+  and what the other world does (`# MT builds: forking is unsupported —
+  raise; single-thread builds take the fork path below`). The existing
+  `isolated_worker.cr` / `gc_arena.cr` sites already approximate this.
+- `macro` definitions live only in **concerns and infrastructure**
+  (`src/models/concerns/`, `src/runtime/`), never in controllers/views/
+  business logic. Every `macro included` carries a comment block listing,
+  by name, the methods/columns it generates (`soft_deletable.cr`'s
+  `column deleted_at` style is halfway there — add the roster comment), so
+  grep-for-definition finds a mention even though the def is generated.
+- No macro-generated *runtime branching* whose shape depends on macro logic
+  (a macro that emits different `if` ladders per include is a puzzle box).
+  Generate declarations and delegations; keep decisions in visible code.
+- `{% for %}` (census: zero) — same fence: declaration generation only.
+**(c) Before/after.**
+```crystal
+# ✅ AED — the ghost branch is narrated for the reader of either world
+def self.run(&block : -> Bytes) : Bytes
+  {% if flag?(:preview_mt) %}
+    # MT builds: fork() after threads exist inherits poisoned locks — refuse loudly.
+    raise UnsupportedError.new("IsolatedWorker.run requires the single-threaded runtime")
+  {% else %}
+    # Single-threaded builds: fork, run the block in the child, reap the bytes.
+    run_in_forked_child(block)
+  {% end %}
+end
+# 🚫 compile-time and runtime conditions braided together — nobody can trace this
+{% if flag?(:gc_agentc) %} if ENABLED && {% if flag?(:preview_mt) %} false {% else %} arena_ready? {% end %} ... {% end %}
+```
+**(d) Cost.** The roster comment can drift from what the macro actually
+generates (comments always can); the "concerns only" fence occasionally
+forces a small concern file where an inline macro felt convenient. Accepted:
+invisible code is the single most expensive thing to hand a coding agent.
+**(e) Mechanical check.** Flag: `{% if` on a line that also contains runtime
+`if`/`unless`; `macro ` definitions outside `src/models/concerns/` and
+`src/runtime/`; `macro included` without a comment containing `generates`
+within 3 lines; nested `{%` inside a method body deeper than one level.
+---
+### How these rules feed documentation generation
+AED's premise for docs: **the names are the source of headings.** Prose docs
+rot; names are re-verified by every compile and every review. Control flow is
+where this pays off most, because control flow *is* the behavior readers ask
+about ("when does it refuse?", "what can go wrong?", "what runs in the
+background?"). Each rule above was written so its mandatory names map onto a
+doc section mechanically:
+| Rule | Named artifact | Doc surface it generates |
+|---|---|---|
+| CF-3 Guards first | The guard block of each public method | **"Refuses when…"** bullet list per operation — each guard line becomes one bullet, its *why*-comment becomes the bullet's explanation. The wire/cose.cr guard stack *is* its security doc. |
+| CF-8 Question methods | `?` predicates referenced by guards & branches | **Glossary of business rules** — `team_lead?`, `oauth_callback_valid?` become glossary entries; the predicate body is the definition. Policy classes' `can?` menus render directly as **permission tables** (action × predicate). |
+| CF-1 Case menus | `case` subject + `when` labels + extracted branch methods | **Decision tables** — "depending on `default_provider`: …" — subject is the table title, when-labels are rows, extracted method names are the outcome column. The mandatory `else` becomes the documented fallback row. |
+| CF-2 Loop finish lines | Loop-extracted body methods, `loop`-named methods | **"Process steps"** — `consume_blockquote`, `emit_table_row` list as the pipeline's stages; `run_heartbeat_loop` names itself in ops docs. |
+| CF-7 Error vocabulary | Typed error classes; typed rescues | **"What can go wrong"** section per module — the error subclass tree renders as the failure catalogue; each typed `rescue` site documents which layer absorbs which failure. This is also compliance evidence (SOC2 loves an error taxonomy). |
+| CF-9 Fiber job titles | Spawn-target method names; channel names | **"Background work"** section — every `spawn`-called method is a row: job title, what it waits on (channel names), its boundary rescue. Ops runbooks can be generated from exactly this. |
+| CF-11 Macro rosters | The `generates:` comment roster | **"Generated API"** appendix per concern — the roster is the contract; docs list it verbatim so generated methods are findable. |
+| CF-10 Suffix promises | `!` doc comments | **Danger callouts** — every `!` method's one-line warning surfaces as a ⚠️ note wherever the method is documented. |
+**What does *not* surface:** ternary values, waypoint locals (CF-6), named
+`Bool` locals (CF-8's one-off form), and cursor predicates — these are
+paragraph-level names for the human reading the file, below the doc
+altitude. The doc generator's selection rule is mechanical: **a control-flow
+name surfaces to docs iff it is a method name** (predicates, branch
+extractions, loop bodies, fiber jobs, error classes). Locals stay local.
+A future `docs/` generator (or a doc-writing agent) therefore needs only:
+method names + `?`/`!` suffixes + guard blocks + case labels + error class
+tree + spawn targets — all extractable with the same grep-grade tooling as
+the mechanical checks in (e). That symmetry is deliberate: **the linter's
+tokens and the doc generator's tokens are the same tokens.**
+---
+### Implementation sketch (if adopted)
+1. Add the accepted rules to `.claude/skills/aed-conventions/SKILL.md` as a
+   "Control flow" section, keeping the existing 6 rules and voice; extend
+   the end-of-edit checklist with one line per rule.
+2. Extend `.claude/hooks/crystal_check.sh` (or a sibling `aed_lint.sh`) with
+   the grep-grade checks from each rule's (e) — start **warn-only**, promote
+   to blocking per-rule once the existing codebase is swept. Candidates for
+   custom Ameba rules later; greps first (same engine, zero deps).
+3. Sweep order by census-weighted payoff: (1) bare rescues → typed/commented
+   (~40 sites), (2) nested `.try` fallbacks (~a dozen sites), (3) compound
+   `unless` (+ the two `spawn do` bodies), (4) case menus without `else`.
+   The website's markdown parser needs no changes — it already conforms to
+   CF-2's cursor-loop shape.
+---
+### Open questions before v1.1.0 final
+These are the thresholds still under review. Each rule above is usable today;
+what is unsettled is exactly where the line falls, not whether the rule holds.
+Opinions are welcome in
+[Discussions](https://github.com/AgentC-Consulting/aed-conventions/discussions).
+1. **Case threshold (CF-1):** Adopt "3+ branches or use if/else", every
+   `when` body ≤ 3 lines, mandatory `else`? Or allow 2-branch `case` when
+   the subject name carries weight?
+2. **Ban `until` outright (CF-2/CF-4)?** Census shows zero uses, so it's
+   free today — but it's idiomatic Crystal and some readers find
+   `until done?` natural. Ban, or allow with single-predicate conditions?
+3. **Guard contiguity (CF-3):** Enforce "all guards before the first story
+   statement" as a hard rule, or as a default with a *why*-comment escape
+   hatch for genuinely late preconditions?
+4. **Bare `rescue ex` at boundaries (CF-7):** Is comment-plus-log sufficient
+   license, or do you want a named helper (`swallowing_errors(context) do`)
+   so boundaries are greppable as one idiom?
+5. **`.try` hard cap (CF-6):** One `.try` per expression is aggressive given
+   98 existing uses — adopt as blocking for new code and sweep old, or
+   warn-only permanently?
+6. **Spawn body = single named call (CF-9):** Apply retroactively to the two
+   existing spawn sites (`isolated_worker.cr`, `mcp_sse_controller.cr`) in
+   the sweep, or grandfather them with comments?
+7. **Enforcement vehicle:** extend `crystal_check.sh` with warn-only greps,
+   write custom Ameba rules, or both (greps now, Ameba when stable)?
+8. **Docs pipeline:** is the "method names surface, locals don't" selection
+   rule right for the doc generator, and which doc surface should be built
+   first — permission tables from policies (cheapest, highest compliance
+   value) or "What can go wrong" from the error tree?
+9. **Ternary strictness (CF-5):** the `success ? "info" : "warning"`
+   argument-position form is blessed; do you also want to allow simple
+   ternaries inside string interpolation (common in view components), or
+   force extraction there too?
+10. **Where does this land?** Fold into the existing SKILL.md as one
+    "Control flow" section (one skill, longer), or a sibling
+    `aed-control-flow` skill file referenced from the main one (two hops,
+    shorter files)?
+---
+*Chapter 06 of the AED canon · the census and code shapes above are drawn from
+AgentC Consulting's own production Crystal, so the rules target real frequency
+rather than theory · back to the [reading order](https://github.com/AgentC-Consulting/aed-conventions/blob/v1.1.0-rc.1/README.md#reading-order)*
+---
+<!-- source: 07_how_the_workflow_runs.md -->
+## How Agent Enhanced Development Work Flows - Local Models
+Typical development processes are that you focus on small steps at a time to scaffold out an idea and then focus on the logic flow. This usually means a lot of saving and rapid iteration. This is actually the least productive way to work with an agent enhanced development process.
+When you are first starting out using an AI agent to assist with developing your app, the temptation is to continue using it for the quick iterative feedback like we currently get from a “write, save, retry” development process. However, with an AI agent enhancing our development process, we are rewarded for planning in detail, and using our natural language. By that I mean, writing and building feature requests in large batches and letting the AI run over many features.
+The agent should be driving the majority of the development, and you should be able to walk away and do something else. It’s a great way to end a day of planning, and then let your laptop sit for a time while the agent runs. It’ll spend the time it needs until it succeeds at building a thorough feature, including your tests.
+This means you can plan your time so that your agent is building your app while you’re typically away from your computer, this way you’re maximizing your local hardware availability while getting the benefits.
+---
+*Chapter 07 of the AED canon · published **verbatim** from the author's original · back to the [reading order](https://github.com/AgentC-Consulting/aed-conventions/blob/v1.1.0-rc.1/README.md#reading-order)*
+---
+<!-- source: quick_reference.md -->
+## Quick Reference - AED Cheat Sheet
+This is a quick reference, please read the entire guide for more details.
+**This is the bare minimum to improve the performance of untrained coding assistants**
+If you're a Rails developer, or come from a similarly structured framework, you'll find a lot of this inspired by the Rails conventions.
+## Naming Conventions
+### General Principles & Guidelines
+- Avoid unnecessary jargon or slang.
+- Never create a whole new lexicon for your code base by applying a theme.
+	- Code names for code bases are entirely acceptable and expected.
+- Names that read like plain English are preferred
+### Object & Attribute Naming Conventions
+- Data models should be singular, and only concerned with their own individual behavior.
+	- Good: `Customer`
+	- Bad: `Customers`
+- Classes should be name spaced according to the feature that is being implemented.
+	- Good: `Billing::ActivateNewCustomerSubscription`
+	- Bad: `NewCustomerSubscription`
+- Class names should be short statements or phrases that clearly express the process being performed.
+	- Good: `PerformCustomerAccountLocking`
+	- Bad: `LockCustomers`
+- Class attributes of non-enumerable primitive types should be phrased as short statements for what the intended purpose of the attribute is.
+	- Example class `Customer`
+	- Well named attribute:  `first_name` or `full_name`
+	- Poorly named attribute: `name`
+- Class attributes of enumerable (Array or Array-like) objects or types should be phrased with `list_of_` or `collection_of_` or `array_of_`
+	- Example class `Customer` has many `Order`s
+	- Well named attribute: `list_of_previous_orders` or `collection_of_previous_orders` or `array_of_previous_orders`
+	- Poorly named attribute: `orders` or `previous_orders`
+	- **Suggestion**: in dynamically typed languages, adding the object type to the end of the name can be very helpful by using the `_as_` phrasing in your naming
+		- Example: `list_of_previous_orders_as_hashes`
+- Class attributes of non-primitive types should be named using short statements or phrases that accurately and clearly express how that attribute is to be used
+	- Example class: `Customer` with a `Subscription`
+	- Ideal: `currently_active_subscription`
+	- Acceptable: `active_subscription`
+	- Bad: `subscription`
+- Class attributes for boolean types should be named as if the expression is a question beginning with `if`
+	- Example class: `Customer`
+	- Good: `has_a_valid_payment_method`
+	- Bad: `payment_method_present`
+### Method Naming Conventions
+- Method names should be phrases or statements that explain the process thats taking place
+	- When possible, include wording to describe the expected return type
+- Method parameters should be named when possible
+	- Ideally as if reading a plain statement
+### File & Folder Naming Conventions
+These primarily apply to domain/business logic. Use your appropriate framework folder structure where necessary. These conventions are primarily if you are using an agent helper that is trained to work with more than 1 file at a time or perform file edits/updates autonomously.
+- The file name should be a lower snake case of the primary class from the file.
+	- Class name `ProcessCustomersWithExpiredSubscriptions`
+	- Filename: `process_customers_with_expired_subscriptions.cr`
+- Classes that are name spaced should be in folders named for that namespace
+	- Class name `Billing::ProcessCustomersWithExpiredSubscriptions`
+	- Filename: `billing/process_customers_with_expired_subscriptions.cr`
+- Data models rarely need to be name spaced.
+	- Reserve this kind of naming for single-table inheritance or other very specific situations where you need a data model to be name spaced.
+Example
+```crystal
+# File found under `billing/process_customers_with_expired_payment_methods`
+class Billing::ProcessCustomersWithExpiredPaymentMethods
+  property collection_of_customers_that_have_expired_payment_methods : Array(Customer) = [] of Customer
+  property collection_of_customers_that_were_retried_and_failed : Array(Customer) = [] of Customer
+  property all_of_the_customers_have_been_processed : Bool = false
+  def initialize(@collection_of_customers_that_have_expired_payment_methods)
+  end
+  def perform
+    retry_customers_who_failed_payment_processing_with_an_expired_card
+    mark_customer_accounts_as_delinquent_and_prevent_further_use
+  end
+  private def retry_customers_who_failed_payment_processing_with_an_expired_card
+    # Your business logic goes here
+  end
+  private def mark_customer_accounts_as_delinquent_and_prevent_further_use
+    # Your business logic goes here
+  end
+end
+```
+### Process Manager Conventions
+Process managers are the starting point of your businesses internal domain-specific language (DSL).
+These objects are _typically_ just a plain class that is not part of a specific framework. Many frameworks have some utilities that bleed out of the framework and into your business logic for common usecase tasks.
+A more formal definition that encompasses what the spirit of the process manager is:
+`Process Manager: a starting point in a business process where a workflow of one or more steps begins and ends, with the final product being the end of the computational process for the business.`
+Process managers conform to the following:
+	- The `initialize` method receives all of the necessary information possible to perform the process
+		- Any necessary data organization should happen during the objects initialization step
+		- Prefer to use named parameters when initializing objects
+	- The entry point method `perform` is defined, and performs all of the methods necessary for the business task to be completed in a single method call
+		- A well written `perform` method will read almost like psuedo code when outlining each step that's being performed.
+	- Use read-only public accessor methods if the object is going to be used for anything other than returning a single result
+	- Use "middle managers" if your business process requires a secondary layer of business logic.
+### Process "Middle" Manager Conventions
+Just like process managers, these are objects that are in your codebase and represent your business process. As a middle manager, they typically are responsible for small parts of a larger process that has complex logic.
+- Middle managers _should be named spaced to the process manager_. These are not meant to be re-used across the code base, just as an organization tool in a large process.
+- Middle managers _do not_ use any other managers.
+## Framework Conventions
+These conventions have (amber)[https://amberframework.org] and (Ruby on Rails)[https://rubyonrails.org] in mind, but any RESTful routing app will tend to follow these well.
+- The standard `Create`, `Edit`, `Update` and `Destroy` will only effect a single resource object.
+- The typical `CRUD` actions should maintain the bare minimum logic to do the following:
+	- a single resource:
+		- Recieve whitelisted parameters
+		- update and validate the target object
+		- Render a response (successful or otherwise)
+	- multiple resources:
+		- Render a response with 0 or more of the desired resource (more commonly known as an index route)
+- Any non-RESTful routes should do the following:
+	- Recieve and validate any incoming parameters or request body
+	- Use a process manager to perform any logic required for the response
+	- Render a response (successful or otherwise)
+A well written Rails controller would look like the following:
+```ruby
+# app/controllers/customers_controller.rb
+class CustomersController < ApplicationController
+  def create
+    @customer = Customer.new(customer_params)
+    if @customer.save
+      render json: @customer, status: :created
+    else
+      render json: @customer.errors, status: :unprocessable_entity
+    end
+  end
+	def update_payment_and_subscription
+    customer = Customer.find(params[:id])
+    new_payment_method = params[:payment_method]
+    if customer && new_payment_method
+      process_manager = Billing::UpdateCustomerPaymentAndSubscription.new(
+        customer: customer,
+        new_payment_method: new_payment_method
+      )
+      if process_manager.perform
+        render json: { message: 'Customer payment method and subscription updated successfully' }, status: :ok
+      else
+        render json: { error: 'Failed to update payment method and subscription' }, status: :unprocessable_entity
+      end
+    else
+      render json: { error: 'Invalid parameters' }, status: :bad_request
+    end
+  end
+  private def customer_params
+    params.require(:customer).permit(:first_name, :last_name, :email)
+  end
+end
+```
+Here's the accompanying process manager:
+```ruby
+module Billing
+  class UpdateCustomerPaymentAndSubscription
+    attr_reader :customer, :new_payment_method
+    def initialize(customer:, new_payment_method:)
+      @customer = customer
+      @new_payment_method = new_payment_method
+    end
+    def perform
+      update_payment_method && update_subscription_status
+    end
+    private def update_payment_method
+      # Implement the logic to update the customer's payment method
+      customer.update(payment_method: new_payment_method)
+    end
+    private def update_subscription_status
+      # Implement the logic to update the customer's subscription status based on the new payment method
+      if customer.payment_method_valid?
+        customer.update(subscription_status: 'active')
+      else
+        customer.update(subscription_status: 'inactive')
+      end
+    end
+  end
+end
+```
+---
+*The AED cheat sheet · published **verbatim** from the author's original · back to the [reading order](https://github.com/AgentC-Consulting/aed-conventions/blob/v1.1.0-rc.1/README.md#reading-order)*

evidence/benchmark_data.json ADDED Viewed

	@@ -0,0 +1,306 @@

+{
+  "benchmark": "AED vs conventional Crystal — small-model comprehension",
+  "date": "2026-07-07",
+  "hypothesis": "AED-style Crystal ('reads like statements', per the premium template's aed-conventions skill) lets smaller models reason about and understand code intent better than conventional compressed style.",
+  "method": {
+    "pairs": 10,
+    "probes_per_variant": 3,
+    "probe_types": [
+      "intent",
+      "modification",
+      "defect"
+    ],
+    "probe_descriptions": {
+      "intent": "Explain what the code does and why (business intent, not line-by-line).",
+      "modification": "Describe how to make a specified behavior change correctly.",
+      "defect": "A subtle behavioral question / planted-defect-style probe about an edge case."
+    },
+    "answering_model": "Claude Haiku (answered blind: never told which style variant it was reading)",
+    "grading": "Graded blind by a model grader that never saw which style produced the answer. 0 = wrong/missed, 1 = partially correct, 2 = fully correct. Max 6 per variant per pair.",
+    "semantic_equivalence": "Each pair's two variants were verified behaviorally identical by a Crystal differential-test harness (scratchpad aed_bench/build_harness.py + tests.cr) that runs both variants against shared checks and diffs outputs.",
+    "runs": "Single run per probe (no repeats).",
+    "note": "Haiku's raw answer transcripts and the grader's rationales were not persisted; this file carries the full source of both variants per pair plus the graded scores, which is sufficient to re-run the probes."
+  },
+  "aggregate": {
+    "aed_total": 60,
+    "conventional_total": 54,
+    "max_per_variant": 60
+  },
+  "per_probe_type_totals": {
+    "aed": {
+      "intent": 20,
+      "modification": 20,
+      "defect": 20
+    },
+    "conventional": {
+      "intent": 18,
+      "modification": 20,
+      "defect": 16
+    },
+    "max_per_cell": 20
+  },
+  "pairs": [
+    {
+      "id": "p1-auth-mfa-routing",
+      "topic": "auth/session logic — post-password MFA routing and pending-challenge TTL",
+      "aed_source": "module Auth\n  # Routes a user who has just passed the password check. The password is only\n  # the FIRST factor: an MFA-enrolled regular user must verify a second factor\n  # before a session is established. Admin accounts have no MFA flag here.\n  module PostPasswordRouter\n    MFA_PENDING_TTL_SECONDS = 300\n\n    def self.next_step(user : Users::Regular | Users::Admin | Nil) : Symbol\n      return :reject_login if user.nil?\n      return :begin_mfa_challenge if second_factor_required?(user)\n\n      :complete_login\n    end\n\n    # Only regular users can enroll in MFA in this template.\n    def self.second_factor_required?(user : Users::Regular | Users::Admin) : Bool\n      if user.is_a?(Users::Regular)\n        user.mfa_enabled\n      else\n        false\n      end\n    end\n\n    # A pending second factor is honored only inside the TTL window; a stale\n    # challenge sends the user back to the password step. This bounds the\n    # window an attacker has to guess codes.\n    def self.mfa_challenge_still_valid?(pending_started_at : Int64?, now : Int64) : Bool\n      return false if pending_started_at.nil?\n\n      seconds_pending = now - pending_started_at\n      seconds_pending <= MFA_PENDING_TTL_SECONDS\n    end\n  end\nend\n",
+      "conventional_source": "module Auth\n  module PostPasswordRouter\n    MFA_PENDING_TTL_SECONDS = 300\n\n    def self.next_step(user : Users::Regular | Users::Admin | Nil) : Symbol\n      return :reject_login unless user\n      user.is_a?(Users::Regular) && user.mfa_enabled ? :begin_mfa_challenge : :complete_login\n    end\n\n    def self.second_factor_required?(user : Users::Regular | Users::Admin) : Bool\n      user.is_a?(Users::Regular) ? user.mfa_enabled : false\n    end\n\n    def self.mfa_challenge_still_valid?(pending_started_at : Int64?, now : Int64) : Bool\n      pending_started_at ? (now - pending_started_at) <= MFA_PENDING_TTL_SECONDS : false\n    end\n  end\nend\n"
+    },
+    {
+      "id": "p2-lead-scoring",
+      "topic": "lead scoring — email-domain classification plus message-effort bonus",
+      "aed_source": "class LeadScorer\n  BUSINESS_DOMAIN_BONUS     =  25\n  SUBSTANTIAL_MESSAGE_LEN   = 120\n  SUBSTANTIAL_MESSAGE_BONUS =  10\n\n  FREE_PROVIDER_DOMAINS = %w[gmail.com yahoo.com outlook.com hotmail.com icloud.com proton.me]\n  DISPOSABLE_DOMAINS    = %w[mailinator.com guerrillamail.com yopmail.com temp-mail.org]\n\n  # Triage score: business senders who write substantively float to the top.\n  def self.score(email : String, message : String) : Int32\n    domain_class = classify_domain(extract_domain(email))\n\n    score = 0\n    score += BUSINESS_DOMAIN_BONUS if domain_class == \"business\"\n    score -= BUSINESS_DOMAIN_BONUS if domain_class == \"suspicious\"\n    score += SUBSTANTIAL_MESSAGE_BONUS if substantial_message?(message)\n    score\n  end\n\n  def self.classify_domain(domain : String) : String\n    return \"unknown\" if domain.empty?\n    return \"suspicious\" if DISPOSABLE_DOMAINS.includes?(domain)\n    return \"free_provider\" if FREE_PROVIDER_DOMAINS.includes?(domain)\n    return \"business\" if plausible_custom_domain?(domain)\n    \"unknown\"\n  end\n\n  # A custom domain must contain a dot that is not at either end.\n  def self.plausible_custom_domain?(domain : String) : Bool\n    domain.includes?('.') && !domain.starts_with?('.') && !domain.ends_with?('.')\n  end\n\n  # A few sentences of detail is a real effort signal vs. a one-liner.\n  def self.substantial_message?(message : String) : Bool\n    message.strip.size >= SUBSTANTIAL_MESSAGE_LEN\n  end\n\n  def self.extract_domain(address : String) : String\n    normalized = address.strip.downcase\n    at_index = normalized.rindex('@')\n    return \"\" unless at_index\n    normalized[(at_index + 1)..].strip\n  end\nend\n",
+      "conventional_source": "class LeadScorer\n  BUSINESS_DOMAIN_BONUS     =  25\n  SUBSTANTIAL_MESSAGE_LEN   = 120\n  SUBSTANTIAL_MESSAGE_BONUS =  10\n\n  FREE_PROVIDER_DOMAINS = %w[gmail.com yahoo.com outlook.com hotmail.com icloud.com proton.me]\n  DISPOSABLE_DOMAINS    = %w[mailinator.com guerrillamail.com yopmail.com temp-mail.org]\n\n  def self.score(email : String, message : String) : Int32\n    dc = classify_domain(extract_domain(email))\n    base = dc == \"business\" ? BUSINESS_DOMAIN_BONUS : dc == \"suspicious\" ? -BUSINESS_DOMAIN_BONUS : 0\n    base + (message.strip.size >= SUBSTANTIAL_MESSAGE_LEN ? SUBSTANTIAL_MESSAGE_BONUS : 0)\n  end\n\n  def self.classify_domain(domain : String) : String\n    case\n    when domain.empty?                                                                 then \"unknown\"\n    when DISPOSABLE_DOMAINS.includes?(domain)                                          then \"suspicious\"\n    when FREE_PROVIDER_DOMAINS.includes?(domain)                                       then \"free_provider\"\n    when domain.includes?('.') && !domain.starts_with?('.') && !domain.ends_with?('.') then \"business\"\n    else                                                                                    \"unknown\"\n    end\n  end\n\n  def self.extract_domain(address : String) : String\n    a = address.strip.downcase\n    (i = a.rindex('@')) ? a[(i + 1)..].strip : \"\"\n  end\nend\n"
+    },
+    {
+      "id": "p3-document-workflow",
+      "topic": "state transitions — document review workflow state machine",
+      "aed_source": "module Documents\n  enum Status\n    Draft\n    InReview\n    Approved\n    Rejected\n    Archived\n  end\n\n  # Review flow for client documents: a document moves strictly\n  # draft -> in_review -> (approved | rejected). A rejected document returns\n  # to draft for revision, only an approved document can be archived, and\n  # archived is terminal, immutable history.\n  module Workflow\n    def self.transition_allowed?(from : Status, to : Status) : Bool\n      allowed_destinations(from).includes?(to)\n    end\n\n    def self.allowed_destinations(from : Status) : Array(Status)\n      if from.draft?\n        [Status::InReview]\n      elsif from.in_review?\n        [Status::Approved, Status::Rejected]\n      elsif from.rejected?\n        [Status::Draft]\n      elsif from.approved?\n        [Status::Archived]\n      else\n        [] of Status\n      end\n    end\n\n    def self.terminal?(status : Status) : Bool\n      allowed_destinations(status).empty?\n    end\n  end\nend\n",
+      "conventional_source": "module Documents\n  enum Status\n    Draft\n    InReview\n    Approved\n    Rejected\n    Archived\n  end\n\n  module Workflow\n    def self.transition_allowed?(from : Status, to : Status) : Bool\n      allowed_destinations(from).includes?(to)\n    end\n\n    def self.allowed_destinations(from : Status) : Array(Status)\n      case from\n      in .draft?     then [Status::InReview]\n      in .in_review? then [Status::Approved, Status::Rejected]\n      in .rejected?  then [Status::Draft]\n      in .approved?  then [Status::Archived]\n      in .archived?  then [] of Status\n      end\n    end\n\n    def self.terminal?(status : Status) : Bool\n      allowed_destinations(status).empty?\n    end\n  end\nend\n"
+    },
+    {
+      "id": "p4-storage-safe-delete",
+      "topic": "file/storage handling — path-safe delete with metadata sidecar",
+      "aed_source": "module Storage\n  # Deletes an object and its metadata sidecar from the local disk store.\n  # Refuses any key that could reach outside the storage root.\n  class LocalObjectRemover\n    getter root : String\n\n    def initialize(@root : String)\n    end\n\n    def delete(key : String) : Bool\n      return false unless safe_key?(key)\n\n      path = File.join(root, key)\n      return false unless File.exists?(path)\n\n      File.delete(path)\n      remove_metadata_sidecar(path)\n      true\n    rescue error\n      Log.error { \"LocalObjectRemover.delete error: #{error.message}\" }\n      false\n    end\n\n    # A key may not be empty, may not be absolute, and may not contain a\n    # \"..\" segment — any of those could escape the storage root.\n    def safe_key?(key : String) : Bool\n      return false if key.empty?\n      return false if key.starts_with?('/')\n      return false if key.split('/').includes?(\"..\")\n      true\n    end\n\n    # Content-type metadata lives in a \"<path>.meta\" sidecar written by put.\n    private def remove_metadata_sidecar(path : String)\n      meta_path = \"#{path}.meta\"\n      File.delete(meta_path) if File.exists?(meta_path)\n    end\n  end\nend\n",
+      "conventional_source": "module Storage\n  class LocalObjectRemover\n    getter root : String\n\n    def initialize(@root : String)\n    end\n\n    def delete(key : String) : Bool\n      return false unless safe_key?(key)\n      path = File.join(root, key)\n      return false unless File.exists?(path)\n      File.delete(path)\n      File.delete(\"#{path}.meta\") if File.exists?(\"#{path}.meta\")\n      true\n    rescue e\n      Log.error { \"LocalObjectRemover.delete error: #{e.message}\" }\n      false\n    end\n\n    def safe_key?(key : String) : Bool\n      !key.empty? && !key.starts_with?('/') && !key.split('/').includes?(\"..\")\n    end\n  end\nend\n"
+    },
+    {
+      "id": "p5-rate-limiter",
+      "topic": "rate limiting — sliding-window per-IP submission ceiling",
+      "aed_source": "# Sliding-window, in-memory rate limit for the contact form: an IP may\n# submit at most MAX_SUBMISSIONS_PER_WINDOW times per rolling hour.\n# Requests without a usable IP are never limited — we fail open on purpose.\nclass SubmissionRateLimiter\n  MAX_SUBMISSIONS_PER_WINDOW = 3\n  WINDOW_SECONDS             = 60 * 60\n\n  def initialize\n    @submission_times_by_ip = Hash(String, Array(Int64)).new\n    @lock = Mutex.new\n  end\n\n  # Records this attempt, then reports whether the IP has now gone over the\n  # ceiling. Every attempt is recorded, even ones that end up limited.\n  def over_limit?(ip : String?, now : Int64) : Bool\n    return false if ip.nil? || ip.empty?\n\n    attempts_in_window = record_and_count(ip, now)\n    attempts_in_window > MAX_SUBMISSIONS_PER_WINDOW\n  end\n\n  private def record_and_count(ip : String, now : Int64) : Int32\n    window_start = now - WINDOW_SECONDS\n\n    @lock.synchronize do\n      recent_times = @submission_times_by_ip[ip]? || Array(Int64).new\n      recent_times.reject! { |time| time < window_start }\n      recent_times << now\n      @submission_times_by_ip[ip] = recent_times\n      recent_times.size\n    end\n  end\nend\n",
+      "conventional_source": "class SubmissionRateLimiter\n  MAX_SUBMISSIONS_PER_WINDOW = 3\n  WINDOW_SECONDS             = 60 * 60\n\n  def initialize\n    @submission_times_by_ip = Hash(String, Array(Int64)).new\n    @lock = Mutex.new\n  end\n\n  def over_limit?(ip : String?, now : Int64) : Bool\n    return false unless ip && !ip.empty?\n    window_start = now - WINDOW_SECONDS\n    @lock.synchronize do\n      times = (@submission_times_by_ip[ip] ||= [] of Int64)\n      times.reject! { |t| t < window_start }\n      times << now\n      times.size > MAX_SUBMISSIONS_PER_WINDOW\n    end\n  end\nend\n"
+    },
+    {
+      "id": "p6-retry-backoff",
+      "topic": "background scheduling — exponential retry backoff with dead-letter cutoff",
+      "aed_source": "module Jobs\n  # Retry policy for failed background jobs: exponential backoff with a cap,\n  # then dead-letter after the final attempt so a poison job cannot retry forever.\n  module RetryPolicy\n    MAX_ATTEMPTS       =   8\n    BASE_DELAY_SECONDS =  30\n    MAX_DELAY_SECONDS  = 600\n\n    # attempts_made counts failures so far, including the one that just happened.\n    def self.next_step(attempts_made : Int32) : {Symbol, Int32}\n      return {:dead_letter, 0} if retries_exhausted?(attempts_made)\n\n      {:retry, delay_before_next_attempt(attempts_made)}\n    end\n\n    def self.retries_exhausted?(attempts_made : Int32) : Bool\n      attempts_made >= MAX_ATTEMPTS\n    end\n\n    # 30s, 60s, 120s ... doubling per failure, never above the ten-minute cap.\n    def self.delay_before_next_attempt(attempts_made : Int32) : Int32\n      uncapped_delay = BASE_DELAY_SECONDS * (2 ** (attempts_made - 1))\n      if uncapped_delay > MAX_DELAY_SECONDS\n        MAX_DELAY_SECONDS\n      else\n        uncapped_delay\n      end\n    end\n  end\nend\n",
+      "conventional_source": "module Jobs\n  module RetryPolicy\n    MAX_ATTEMPTS       =   8\n    BASE_DELAY_SECONDS =  30\n    MAX_DELAY_SECONDS  = 600\n\n    def self.next_step(attempts_made : Int32) : {Symbol, Int32}\n      attempts_made >= MAX_ATTEMPTS ? {:dead_letter, 0} : {:retry, delay_before_next_attempt(attempts_made)}\n    end\n\n    def self.retries_exhausted?(attempts_made : Int32) : Bool\n      attempts_made >= MAX_ATTEMPTS\n    end\n\n    def self.delay_before_next_attempt(attempts_made : Int32) : Int32\n      Math.min(BASE_DELAY_SECONDS * (2 ** (attempts_made - 1)), MAX_DELAY_SECONDS)\n    end\n  end\nend\n"
+    },
+    {
+      "id": "p7-inquiry-validation",
+      "topic": "validation — collect-all-errors form validation for inquiry submissions",
+      "aed_source": "# Field-level validation for the /stroll inquiry form. Returns every error\n# at once so the visitor can fix the whole form in one pass.\nclass InquiryValidator\n  MIN_MESSAGE_LENGTH =   20\n  MAX_MESSAGE_LENGTH = 5000\n\n  getter name : String\n  getter email : String\n  getter message : String\n\n  def initialize(@name : String, @email : String, @message : String)\n  end\n\n  def errors : Array(String)\n    found = [] of String\n    found << \"Name is required\" if name_is_blank?\n    found << \"Email address does not look valid\" unless email_looks_deliverable?\n    found << \"Message must be at least #{MIN_MESSAGE_LENGTH} characters\" if message_too_short?\n    found << \"Message must be under #{MAX_MESSAGE_LENGTH} characters\" if message_too_long?\n    found\n  end\n\n  def valid? : Bool\n    errors.empty?\n  end\n\n  private def name_is_blank? : Bool\n    name.strip.empty?\n  end\n\n  # Deliberately loose: just a \"local@domain.tld\" shape. Real deliverability\n  # is judged later by the MX lookup in lead scoring.\n  private def email_looks_deliverable? : Bool\n    email.matches?(/\\A[^@\\s]+@[^@\\s]+\\.[^@\\s]+\\z/)\n  end\n\n  private def message_too_short? : Bool\n    message.strip.size < MIN_MESSAGE_LENGTH\n  end\n\n  private def message_too_long? : Bool\n    message.strip.size > MAX_MESSAGE_LENGTH\n  end\nend\n",
+      "conventional_source": "class InquiryValidator\n  MIN_MESSAGE_LENGTH =   20\n  MAX_MESSAGE_LENGTH = 5000\n  EMAIL_FORMAT       = /\\A[^@\\s]+@[^@\\s]+\\.[^@\\s]+\\z/\n\n  getter name : String\n  getter email : String\n  getter message : String\n\n  def initialize(@name : String, @email : String, @message : String)\n  end\n\n  def errors : Array(String)\n    e = [] of String\n    e << \"Name is required\" if name.strip.empty?\n    e << \"Email address does not look valid\" unless email.matches?(EMAIL_FORMAT)\n    m = message.strip.size\n    e << \"Message must be at least #{MIN_MESSAGE_LENGTH} characters\" if m < MIN_MESSAGE_LENGTH\n    e << \"Message must be under #{MAX_MESSAGE_LENGTH} characters\" if m > MAX_MESSAGE_LENGTH\n    e\n  end\n\n  def valid? : Bool\n    errors.empty?\n  end\nend\n"
+    },
+    {
+      "id": "p8-rbac-document-policy",
+      "topic": "RBAC checks — admin/owner bypass plus org-role gated document actions",
+      "aed_source": "module Authorization\n  # Access rules for client documents. Admins bypass all checks; a document's\n  # owner has full control; organization members act by role — editors may\n  # read and update, viewers may only read. Everyone else is denied.\n  class DocumentPolicy\n    getter user_id : Int64\n    getter user_is_admin : Bool\n    getter org_role : String?\n\n    def initialize(@user_id : Int64, @user_is_admin : Bool, @org_role : String?)\n    end\n\n    def can?(action : Symbol, owner_id : Int64) : Bool\n      return true if user_is_admin\n      return true if owns_document?(owner_id)\n      return can_act_as_editor?(action) if org_role == \"editor\"\n      return action == :read if org_role == \"viewer\"\n\n      false\n    end\n\n    private def owns_document?(owner_id : Int64) : Bool\n      user_id == owner_id\n    end\n\n    # Editors may change content but never destroy it.\n    private def can_act_as_editor?(action : Symbol) : Bool\n      action == :read || action == :update\n    end\n  end\nend\n",
+      "conventional_source": "module Authorization\n  class DocumentPolicy\n    getter user_id : Int64\n    getter user_is_admin : Bool\n    getter org_role : String?\n\n    def initialize(@user_id : Int64, @user_is_admin : Bool, @org_role : String?)\n    end\n\n    def can?(action : Symbol, owner_id : Int64) : Bool\n      return true if user_is_admin || user_id == owner_id\n      case org_role\n      when \"editor\" then action == :read || action == :update\n      when \"viewer\" then action == :read\n      else               false\n      end\n    end\n  end\nend\n"
+    },
+    {
+      "id": "p9-lead-badge-rendering",
+      "topic": "ECR-adjacent rendering — score-tier badge HTML with escaping",
+      "aed_source": "module Views\n  # Renders the score badge shown beside each inquiry in the /stroll inbox.\n  # Tiers make the score glanceable so hot leads float to the top of triage.\n  module LeadBadge\n    HOT_THRESHOLD  = 40\n    WARM_THRESHOLD = 15\n\n    def self.tier(score : Int32) : String\n      return \"hot\" if score >= HOT_THRESHOLD\n      return \"warm\" if score >= WARM_THRESHOLD\n      return \"cold\" if score >= 0\n      \"junk\"\n    end\n\n    # The domain comes from user input, so it is HTML-escaped before it is\n    # interpolated into markup.\n    def self.badge_html(score : Int32, email_domain : String) : String\n      badge_tier = tier(score)\n      escaped_domain = HTML.escape(email_domain)\n\n      String.build do |html|\n        html << %(<span class=\"lead-badge lead-badge--#{badge_tier}\" data-score=\"#{score}\">)\n        html << badge_tier.upcase\n        html << \" · \"\n        html << escaped_domain\n        html << \"</span>\"\n      end\n    end\n  end\nend\n",
+      "conventional_source": "module Views\n  module LeadBadge\n    HOT_THRESHOLD  = 40\n    WARM_THRESHOLD = 15\n\n    def self.tier(score : Int32) : String\n      score >= HOT_THRESHOLD ? \"hot\" : score >= WARM_THRESHOLD ? \"warm\" : score >= 0 ? \"cold\" : \"junk\"\n    end\n\n    def self.badge_html(score : Int32, email_domain : String) : String\n      t = tier(score)\n      %(<span class=\"lead-badge lead-badge--#{t}\" data-score=\"#{score}\">#{t.upcase} · #{HTML.escape(email_domain)}</span>)\n    end\n  end\nend\n"
+    },
+    {
+      "id": "p10-mail-queue-triage",
+      "topic": "queue/status flow — outbound-mail worker triage with stale-lock reclaim",
+      "aed_source": "module Mailer\n  # Decides what the queue worker should do with one outbound email row.\n  # Pending mail goes out once its scheduled time arrives. A \"processing\" row\n  # whose lock is older than the stale threshold belonged to a crashed worker\n  # and is reclaimed; anything already sent or failed is left alone.\n  module QueueTriage\n    STALE_LOCK_SECONDS = 15 * 60\n\n    def self.decision(status : String, scheduled_at : Int64, locked_at : Int64?, now : Int64) : Symbol\n      if status == \"pending\"\n        if due_for_delivery?(scheduled_at, now)\n          return :deliver\n        else\n          return :not_due_yet\n        end\n      end\n\n      if status == \"processing\"\n        return :reclaim if lock_gone_stale?(locked_at, now)\n        return :leave_alone\n      end\n\n      :leave_alone\n    end\n\n    def self.due_for_delivery?(scheduled_at : Int64, now : Int64) : Bool\n      scheduled_at <= now\n    end\n\n    # A worker that dies mid-send leaves the row locked; after 15 minutes we\n    # assume the worker is gone and give the row back to the queue.\n    def self.lock_gone_stale?(locked_at : Int64?, now : Int64) : Bool\n      return false if locked_at.nil?\n\n      (now - locked_at) > STALE_LOCK_SECONDS\n    end\n  end\nend\n",
+      "conventional_source": "module Mailer\n  module QueueTriage\n    STALE_LOCK_SECONDS = 15 * 60\n\n    def self.decision(status : String, scheduled_at : Int64, locked_at : Int64?, now : Int64) : Symbol\n      case status\n      when \"pending\"    then scheduled_at <= now ? :deliver : :not_due_yet\n      when \"processing\" then locked_at && (now - locked_at) > STALE_LOCK_SECONDS ? :reclaim : :leave_alone\n      else                   :leave_alone\n      end\n    end\n\n    def self.due_for_delivery?(scheduled_at : Int64, now : Int64) : Bool\n      scheduled_at <= now\n    end\n\n    def self.lock_gone_stale?(locked_at : Int64?, now : Int64) : Bool\n      locked_at ? (now - locked_at) > STALE_LOCK_SECONDS : false\n    end\n  end\nend\n"
+    }
+  ],
+  "scored_runs": [
+    {
+      "pair": "p1-auth-mfa-routing",
+      "variant": "aed",
+      "scores_by_probe": {
+        "intent": 2,
+        "modification": 2,
+        "defect": 2
+      },
+      "pair_total": 6
+    },
+    {
+      "pair": "p1-auth-mfa-routing",
+      "variant": "conventional",
+      "scores_by_probe": {
+        "intent": 2,
+        "modification": 2,
+        "defect": 2
+      },
+      "pair_total": 6
+    },
+    {
+      "pair": "p2-lead-scoring",
+      "variant": "aed",
+      "scores_by_probe": {
+        "intent": 2,
+        "modification": 2,
+        "defect": 2
+      },
+      "pair_total": 6
+    },
+    {
+      "pair": "p2-lead-scoring",
+      "variant": "conventional",
+      "scores_by_probe": {
+        "intent": 2,
+        "modification": 2,
+        "defect": 2
+      },
+      "pair_total": 6
+    },
+    {
+      "pair": "p3-document-workflow",
+      "variant": "aed",
+      "scores_by_probe": {
+        "intent": 2,
+        "modification": 2,
+        "defect": 2
+      },
+      "pair_total": 6
+    },
+    {
+      "pair": "p3-document-workflow",
+      "variant": "conventional",
+      "scores_by_probe": {
+        "intent": 1,
+        "modification": 2,
+        "defect": 0
+      },
+      "pair_total": 3
+    },
+    {
+      "pair": "p4-storage-safe-delete",
+      "variant": "aed",
+      "scores_by_probe": {
+        "intent": 2,
+        "modification": 2,
+        "defect": 2
+      },
+      "pair_total": 6
+    },
+    {
+      "pair": "p4-storage-safe-delete",
+      "variant": "conventional",
+      "scores_by_probe": {
+        "intent": 2,
+        "modification": 2,
+        "defect": 2
+      },
+      "pair_total": 6
+    },
+    {
+      "pair": "p5-rate-limiter",
+      "variant": "aed",
+      "scores_by_probe": {
+        "intent": 2,
+        "modification": 2,
+        "defect": 2
+      },
+      "pair_total": 6
+    },
+    {
+      "pair": "p5-rate-limiter",
+      "variant": "conventional",
+      "scores_by_probe": {
+        "intent": 2,
+        "modification": 2,
+        "defect": 2
+      },
+      "pair_total": 6
+    },
+    {
+      "pair": "p6-retry-backoff",
+      "variant": "aed",
+      "scores_by_probe": {
+        "intent": 2,
+        "modification": 2,
+        "defect": 2
+      },
+      "pair_total": 6
+    },
+    {
+      "pair": "p6-retry-backoff",
+      "variant": "conventional",
+      "scores_by_probe": {
+        "intent": 2,
+        "modification": 2,
+        "defect": 2
+      },
+      "pair_total": 6
+    },
+    {
+      "pair": "p7-inquiry-validation",
+      "variant": "aed",
+      "scores_by_probe": {
+        "intent": 2,
+        "modification": 2,
+        "defect": 2
+      },
+      "pair_total": 6
+    },
+    {
+      "pair": "p7-inquiry-validation",
+      "variant": "conventional",
+      "scores_by_probe": {
+        "intent": 1,
+        "modification": 2,
+        "defect": 2
+      },
+      "pair_total": 5
+    },
+    {
+      "pair": "p8-rbac-document-policy",
+      "variant": "aed",
+      "scores_by_probe": {
+        "intent": 2,
+        "modification": 2,
+        "defect": 2
+      },
+      "pair_total": 6
+    },
+    {
+      "pair": "p8-rbac-document-policy",
+      "variant": "conventional",
+      "scores_by_probe": {
+        "intent": 2,
+        "modification": 2,
+        "defect": 2
+      },
+      "pair_total": 6
+    },
+    {
+      "pair": "p9-lead-badge-rendering",
+      "variant": "aed",
+      "scores_by_probe": {
+        "intent": 2,
+        "modification": 2,
+        "defect": 2
+      },
+      "pair_total": 6
+    },
+    {
+      "pair": "p9-lead-badge-rendering",
+      "variant": "conventional",
+      "scores_by_probe": {
+        "intent": 2,
+        "modification": 2,
+        "defect": 2
+      },
+      "pair_total": 6
+    },
+    {
+      "pair": "p10-mail-queue-triage",
+      "variant": "aed",
+      "scores_by_probe": {
+        "intent": 2,
+        "modification": 2,
+        "defect": 2
+      },
+      "pair_total": 6
+    },
+    {
+      "pair": "p10-mail-queue-triage",
+      "variant": "conventional",
+      "scores_by_probe": {
+        "intent": 2,
+        "modification": 2,
+        "defect": 0
+      },
+      "pair_total": 4
+    }
+  ]
+}

evidence/haiku_comprehension_report.md ADDED Viewed

	@@ -0,0 +1,231 @@

+# AED vs Conventional Crystal — Small-Model Comprehension Benchmark
+**Date**: 2026-07-07
+**Answering model**: Claude Haiku
+**Raw data**: [`evidence/benchmark_data.json`](./benchmark_data.json) (full source of every pair variant + per-probe scores)
+**Conventions under test**: `.claude/skills/aed-conventions/SKILL.md` ("reads like statements")
+---
+## Verdict (read this first, including the caveats)
+In this run, AED-style Crystal scored **60/60** and conventional compressed
+style scored **54/60** when Claude Haiku answered comprehension probes blind
+and a blind grader scored the answers. AED never lost a probe; conventional
+lost points on 3 of 10 pairs, concentrated in **defect-finding** (16/20) and
+**intent** (18/20) probes, while **modification** probes tied (20/20 each).
+What this run **does** establish: on these 10 snippet-scale pairs, one small
+Claude model, one attempt each, the AED variant never performed worse and
+performed better exactly where the hypothesis predicts — understanding *why*
+code exists and spotting subtle behavioral edges, not mechanical edits.
+What this run **does not** establish: that AED helps at codebase scale, that
+the effect survives repeated sampling (single run, no variance estimate), that
+it generalizes beyond Haiku or beyond the Claude family, that a human grader
+would agree with the model grader, or that the gain comes from AED's *syntax
+rules* specifically rather than the whole AED bundle (expanded control flow +
+intent-bearing names + intent comments travel together in the AED variants).
+A 6-point gap on n=10 with 7 ceiling ties is a **directional signal
+consistent with the hypothesis, not proof of it**.
+---
+## Hypothesis
+AED-style Crystal ("reads like statements", per the premium template's
+`aed-conventions` skill) lets **smaller** models reason about and understand
+code intent better than conventional compressed style. The theory: compressed
+syntax (dense `case … in` ladders, ternaries inside `when` arms, single-letter
+locals, chained expressions) forces a re-parse that big models absorb but
+small models pay for.
+## Method
+- **10 pairs** of Crystal snippets (15–45 lines each), one AED variant and one
+  conventional variant per pair, covering auth, scoring, state machines,
+  storage, rate limiting, retries, validation, RBAC, rendering, and queue
+  triage (full list in the appendix).
+- **Semantic equivalence enforced**: both variants of each pair were run
+  through a differential-test harness (shared checks, outputs diffed) so the
+  probes measure *style*, not behavior differences.
+- **3 probes per variant**, same probes for both variants of a pair:
+  1. **Intent** — explain what the code does and why (business intent).
+  2. **Modification** — describe how to make a specified behavior change.
+  3. **Defect** — a subtle edge-case/behavioral question.
+- **Blind answering**: Claude Haiku saw one variant at a time and was never
+  told a style comparison was happening.
+- **Blind grading**: a model grader scored each answer 0/1/2 (wrong / partial /
+  fully correct) without seeing which style produced the code or the answer.
+  Max 6 points per variant per pair, 60 per style overall.
+**Honest limits of the method, stated up front**: n=10 pairs; **one** small
+model; **single run** per probe (no repeats, so no variance estimate); the
+grader is **also a model**, so grader error or grader style-affinity is
+uncorrected; and the pairs were authored by the same party that authored the
+conventions.
+## Results
+### Aggregate
+| Style | Total | Max |
+|---|---:|---:|
+| **AED** | **60** | 60 |
+| Conventional | 54 | 60 |
+### Per probe type (computed from the per-run data)
+| Probe type | AED | Conventional | Gap |
+|---|---:|---:|---:|
+| Intent | 20/20 | 18/20 | +2 |
+| Modification | 20/20 | 20/20 | 0 |
+| Defect | 20/20 | 16/20 | **+4** |
+The gap lives almost entirely in **defect probes** (two outright zeros for
+conventional) and partially in **intent probes** (two partial credits).
+**Modification probes showed no difference at all** — when Haiku is told
+exactly what change to make, compressed style did not slow it down. The style
+seems to matter when the model must *infer* purpose or *notice* an edge case,
+not when it is executing instructions. That is precisely the split the
+hypothesis predicts, which is encouraging — and also exactly what a
+motivated benchmark author would produce, which is why replication matters.
+### Per pair
+| Pair | AED | Conventional | Δ |
+|---|---:|---:|---:|
+| p3 document-workflow (state machine) | 6 | 3 | **+3** |
+| p10 mail-queue-triage (stale-lock reclaim) | 6 | 4 | **+2** |
+| p7 inquiry-validation (collect-all-errors) | 6 | 5 | +1 |
+| the other 7 pairs | 6 | 6 | 0 |
+## The most instructive contrasts
+**Where AED helped most — p3, the document review state machine (6 vs 3).**
+The conventional variant expresses the whole workflow as a `case … in` ladder
+with dot-shorthand predicates (`in .draft? then [Status::InReview]`) and no
+comment. Haiku scored only partial credit on intent and **zero on the defect
+probe**. The AED variant spells out the same transitions as an `if/elsif`
+chain under a comment stating the review flow ("a rejected document returns
+to draft… archived is terminal"). This is the single strongest data point for
+the conventions' Rule 1 territory: compressed exhaustive-match syntax is
+exactly where the small model lost the thread of *policy*.
+**Where AED helped — p10, outbound-mail queue triage (6 vs 4).** The
+conventional variant packs each `when` arm with a ternary
+(`scheduled_at <= now ? :deliver : :not_due_yet`) and inlines the stale-lock
+math; Haiku scored **zero on the defect probe**. The AED variant hoists the
+same logic into named predicates (`due_for_delivery?`, `lock_gone_stale?`)
+with a comment explaining that a stale lock means a crashed worker. Notably
+this is the pattern the control-flow proposal targets (ternaries inside
+branch arms; nil-guard ternaries like `locked_at ? … : false`).
+**Where AED helped a little — p7, inquiry validation (6 vs 5).** Conventional
+uses single-letter locals (`e` for the error array, `m` for message length)
+and postfix conditionals; Haiku dropped to partial credit on the *intent*
+probe only. Mild evidence that naming, not control flow, was the friction
+here.
+**Where AED did not help — the other seven pairs (ties at 6/6).** Auth/MFA
+routing, lead scoring, safe delete, rate limiting, retry backoff, RBAC
+policy, and badge rendering were all answered perfectly in both styles.
+Reading those conventional variants, they are compressed but short and
+single-purpose; Haiku handled them fine. **AED never hurt** in this run —
+there is no pair where the AED variant scored lower — but on 70% of pairs it
+also bought nothing measurable, because the test was too easy. The
+discriminating pairs were the ones with *branchy policy logic* (state
+machine, queue triage), which is consistent with the census in
+`AED_CONTROL_FLOW_PROPOSAL.md` showing control flow is where the real
+codebase's complexity lives.
+## Threats to validity
+1. **Small n, single run.** 10 pairs, 30 probes per style, one sample per
+   probe. Model outputs are stochastic; a 6-point gap could shrink (or grow)
+   under repeated sampling. No confidence interval is possible from one run.
+2. **Ceiling effect.** 7 of 10 pairs tied at the maximum. The instrument was
+   too easy for most pairs, so the aggregate compresses toward a tie and the
+   signal rests on 3 pairs. Harder probes would give a more sensitive read.
+3. **One model, one family.** Only Claude Haiku answered. Other small models
+   (and non-Claude families) may parse compressed Crystal differently.
+4. **Model-graded.** The grader is a model. It graded blind to style, but it
+   can still systematically prefer answers that echo intent-comment phrasing
+   — which AED variants contain and conventional variants do not.
+5. **Style bundle confound.** The AED variants differ from conventional in
+   *several* ways at once: expanded control flow, named predicates, AND
+   intent-bearing comments (e.g. p3's workflow comment exists only in the AED
+   variant). This run cannot attribute the gap to syntax rules specifically;
+   the comments alone might explain the intent-probe gap. An ablation is
+   needed.
+6. **Length/token asymmetry.** AED variants are consistently longer (e.g.
+   p10: 38 vs 21 lines). More tokens restating the logic may itself aid a
+   small model, independent of *how* the code reads.
+7. **Author bias.** Pairs, probes, and both variants were authored inside the
+   AgentC ecosystem by the conventions' proponents. Even in good faith, pair
+   selection and probe design can tilt toward AED's strengths.
+8. **Snippet scale.** 15–45-line snippets are not a codebase. AED's costs
+   (more lines to read per function, more scrolling) and benefits may both
+   scale differently across files and call graphs.
+## What to test next
+1. **Larger n with repeats**: 30–50 pairs, 3–5 samples per probe, report
+   variance and a paired significance test rather than a single tally.
+2. **Harder probes**: calibrate so the conventional baseline lands near
+   50–70%, eliminating the ceiling that muted 7 of 10 pairs.
+3. **More models, including non-Claude**: at minimum another Claude tier plus
+   two non-Claude small models, to separate "AED helps small models" from
+   "AED helps Haiku".
+4. **Human graders** on a subsample (or full set) to validate the model
+   grader; report agreement.
+5. **Ablations to break the bundle**: comments-only, naming-only, and
+   control-flow-only variants, so the conventions' individual rules earn
+   their keep separately.
+6. **The control-flow proposal's new rules, once adopted**: p3 and p10 — the
+   two biggest gaps — are precisely `case` ladders and ternary-in-branch
+   patterns that `AED_CONTROL_FLOW_PROPOSAL.md` addresses. Re-run with pairs
+   written to the new rules to test whether they capture the effect.
+7. **Codebase-scale tasks**: multi-file comprehension and real modification
+   tasks in the template itself, not snippets, to test the claim where it
+   actually matters.
+---
+## Appendix A — Full scored table
+Probe order: intent, modification, defect. Each probe scored 0–2.
+| Pair | Topic | Variant | Intent | Modification | Defect | Total |
+|---|---|---|---:|---:|---:|---:|
+| p1-auth-mfa-routing | auth/session — post-password MFA routing and pending-challenge TTL | aed | 2 | 2 | 2 | 6 |
+| p1-auth-mfa-routing | | conventional | 2 | 2 | 2 | 6 |
+| p2-lead-scoring | lead scoring — email-domain classification plus message-effort bonus | aed | 2 | 2 | 2 | 6 |
+| p2-lead-scoring | | conventional | 2 | 2 | 2 | 6 |
+| p3-document-workflow | state transitions — document review workflow state machine | aed | 2 | 2 | 2 | 6 |
+| p3-document-workflow | | conventional | 1 | 2 | 0 | 3 |
+| p4-storage-safe-delete | file/storage — path-safe delete with metadata sidecar | aed | 2 | 2 | 2 | 6 |
+| p4-storage-safe-delete | | conventional | 2 | 2 | 2 | 6 |
+| p5-rate-limiter | rate limiting — sliding-window per-IP submission ceiling | aed | 2 | 2 | 2 | 6 |
+| p5-rate-limiter | | conventional | 2 | 2 | 2 | 6 |
+| p6-retry-backoff | background scheduling — exponential retry backoff with dead-letter cutoff | aed | 2 | 2 | 2 | 6 |
+| p6-retry-backoff | | conventional | 2 | 2 | 2 | 6 |
+| p7-inquiry-validation | validation — collect-all-errors form validation for inquiry submissions | aed | 2 | 2 | 2 | 6 |
+| p7-inquiry-validation | | conventional | 1 | 2 | 2 | 5 |
+| p8-rbac-document-policy | RBAC — admin/owner bypass plus org-role gated document actions | aed | 2 | 2 | 2 | 6 |
+| p8-rbac-document-policy | | conventional | 2 | 2 | 2 | 6 |
+| p9-lead-badge-rendering | ECR-adjacent rendering — score-tier badge HTML with escaping | aed | 2 | 2 | 2 | 6 |
+| p9-lead-badge-rendering | | conventional | 2 | 2 | 2 | 6 |
+| p10-mail-queue-triage | queue/status flow — outbound-mail worker triage with stale-lock reclaim | aed | 2 | 2 | 2 | 6 |
+| p10-mail-queue-triage | | conventional | 2 | 2 | 0 | 4 |
+| **Totals** | | **aed** | **20** | **20** | **20** | **60** |
+| | | **conventional** | **18** | **20** | **16** | **54** |
+## Appendix B — Reproducibility
+`docs/aed_benchmark_data.json` contains the complete Crystal source of both
+variants for all 10 pairs, the probe-type definitions, the grading rubric,
+and every per-probe score. Haiku's raw answer transcripts and the grader's
+rationales were **not** persisted from this run — a re-run should archive
+them; the sources and probes in the JSON are sufficient to repeat the
+experiment.

examples/01_branch_on_type.cr ADDED Viewed

	@@ -0,0 +1,57 @@

+# AED Rule 1 — Branch on type with an explicit `if … is_a?`, not a clever `case`
+#
+# Context: a login controller that stores a different session shape depending
+# on which kind of user just authenticated. `user` is a union type
+# (Users::Regular | Users::Admin) returned by an ORM lookup.
+# ── BEFORE ────────────────────────────────────────────────────────────────────
+# `case … in` demands exhaustive matching and, under the Grant ORM's
+# `Grant::Base+` inference, fails to compile:
+#   Error: case is not exhaustive. Missing types: Grant::Base
+#
+#   case user
+#   in Users::Regular
+#     session[:user_type] = "regular"
+#     session[:session_version] = user.session_version
+#   in Users::Admin
+#     session[:user_type] = "admin"
+#   end
+#
+# The dot-receiver sugar compiles, but the leading dot is a riddle the reader
+# must decode before they even reach the branch bodies:
+#
+#   case user
+#   when .is_a?(Users::Regular)
+#     session[:user_type] = "regular"
+#     session[:session_version] = user.session_version
+#   when .is_a?(Users::Admin)
+#     session[:user_type] = "admin"
+#   end
+# ── AFTER (AED) ───────────────────────────────────────────────────────────────
+# An ordinary `if` reads like a sentence: "if the user is a regular user,
+# record a regular session; otherwise it is an admin session."
+#
+# Minimal stand-ins for the union type and session store this snippet was
+# excerpted from, so the file compiles standalone:
+module Users
+  class Regular
+    getter session_version : Int32
+    def initialize(@session_version : Int32)
+    end
+  end
+  class Admin
+  end
+end
+def record_session(user : Users::Regular | Users::Admin, session : Hash(Symbol, String | Int32)) : Nil
+  if user.is_a?(Users::Regular)
+    session[:user_type] = "regular"
+    session[:session_version] = user.session_version
+  else
+    session[:user_type] = "admin"
+  end
+end

examples/02_name_the_thing.cr ADDED Viewed

	@@ -0,0 +1,32 @@

+# AED Rule 2 — Name the thing; don't make the reader decode a chain
+#
+# Context: an OAuth callback verifying the `state` parameter against the value
+# issued at the start of the flow. This is security-critical code — exactly
+# where a reader (human or agent) must be able to verify intent at a glance.
+# ── BEFORE ────────────────────────────────────────────────────────────────────
+# Terse, but the reader has to hold three operations in their head at once:
+# a nilable session lookup, a block binding, and a comparison — all inside a
+# negated guard.
+#
+#   return unless session["oauth_state"]?.try { |s| constant_time_equal?(s, state) }
+# ── AFTER (AED) ───────────────────────────────────────────────────────────────
+# Naming the intermediate turns the same logic into two plain statements:
+# "this is the state we expected; refuse unless it exists and matches."
+#
+# Minimal stand-ins for the session store and comparison helper this snippet
+# was excerpted from, so the file compiles standalone:
+def constant_time_equal?(a : String, b : String) : Bool
+  return false if a.bytesize != b.bytesize
+  mismatch = 0
+  a.bytes.each_with_index { |byte, i| mismatch |= byte ^ b.bytes[i] }
+  mismatch == 0
+end
+def verify_oauth_callback(session : Hash(String, String), state : String) : Nil
+  expected_state = session["oauth_state"]?
+  return unless expected_state && constant_time_equal?(expected_state, state)
+end

examples/03_guard_clauses.cr ADDED Viewed

	@@ -0,0 +1,24 @@

+# AED Rule 3 — Prefer explicit guard clauses to nested ternaries / one-liners
+#
+# Context: a password-verification method on a user model. Returns the user
+# on success, nil on any failure. The guard-clause form doubles as the
+# security argument: each line is one condition under which entry is refused.
+# ── BEFORE ────────────────────────────────────────────────────────────────────
+# One line, two nested ternaries, three outcomes. The author saved four lines;
+# every future reader re-parses the precedence to find out what happens when.
+#
+#   def verify_password(password : String) : self?
+#     password_digest.empty? ? nil : (Crypto::Bcrypt::Password.new(password_digest).verify(password) ? self : nil)
+#   end
+# ── AFTER (AED) ───────────────────────────────────────────────────────────────
+# The guards read as a doorman's checklist: no digest, no entry; wrong
+# password, no entry. Everything after the guards assumes both checks passed.
+def verify_password(password : String) : self?
+  return nil if password_digest.empty?
+  return nil unless Crypto::Bcrypt::Password.new(password_digest).verify(password)
+  self
+end

examples/04_reader_first_names_and_comments.cr ADDED Viewed

	@@ -0,0 +1,33 @@

+# AED Rules 4 + 5 — Intention-revealing names; comments say WHY, never WHAT
+#
+# Context: session establishment after a successful login. The same behavior,
+# written twice. Note that the AFTER version has FEWER comments — good names
+# removed the need for most of them, and the one comment that remains carries
+# information the code cannot: the attack it prevents.
+# ── BEFORE ────────────────────────────────────────────────────────────────────
+# Cryptic names force a comment per line, and every comment restates the code.
+#
+#   # process the user
+#   def do_it(u)
+#     # reset the session
+#     session.reset
+#     # set the id
+#     session[:uid] = u.id
+#     # set the version
+#     tmp = u.session_version
+#     session[:sv] = tmp
+#   end
+# ── AFTER (AED) ───────────────────────────────────────────────────────────────
+# The method name states the intent; the locals state what they hold; the one
+# surviving comment explains a security decision no name could carry.
+def establish_session(user : Users::Regular) : Nil
+  # Rotate the session id BEFORE writing identity: prevents session fixation
+  # (an attacker pre-planting a known session id that survives login).
+  session.reset
+  session[:user_id] = user.id
+  session[:session_version] = user.session_version
+end

examples/README.md ADDED Viewed

	@@ -0,0 +1,15 @@

+# Examples — before/after, one rule cluster per file
+Each file shows the shorthand form (BEFORE, commented out — some deliberately
+do not compile, that is part of the point) and the AED form (AFTER, live code)
+for one rule from [../CONVENTIONS.md](../CONVENTIONS.md).
+| File | Rule | The move |
+|---|---|---|
+| [01_branch_on_type.cr](01_branch_on_type.cr) | [Rule 1](../CONVENTIONS.md#rule-1) | `case … in` / dot-riddle `case` → explicit `if … is_a?` |
+| [02_name_the_thing.cr](02_name_the_thing.cr) | [Rule 2](../CONVENTIONS.md#rule-2) | decoded chain → named intermediate |
+| [03_guard_clauses.cr](03_guard_clauses.cr) | [Rule 3](../CONVENTIONS.md#rule-3) | nested ternary → guard clauses |
+| [04_reader_first_names_and_comments.cr](04_reader_first_names_and_comments.cr) | [Rules 4](../CONVENTIONS.md#rule-4) + [5](../CONVENTIONS.md#rule-5) | cryptic names / what-comments → intention-revealing names / why-comments |
+The test applied throughout: **does a reader who has never seen this code
+understand the intent on first pass?** If they must mentally execute it, expand it.

llms.txt ADDED Viewed

	@@ -0,0 +1,89 @@

+# AED Conventions — Agent-Enhanced Development
+> Code conventions for codebases maintained by humans and coding agents
+> together. Core rule: prefer the form that reads like a plain statement of
+> intent; use shorthand only when it makes intent clearer, never just shorter.
+> Maintained by AgentC Consulting (https://agentc.consulting). This repository
+> (https://github.com/AgentC-Consulting/aed-conventions) is the canonical
+> source; mirrors elsewhere point back here. Cite this repo when applying
+> these rules.
+>
+> Current version: v1.1.0-rc.1 (release candidate). Pin to the tag, not to
+> main — main still carries v1.0.0 until this candidate is promoted.
+If you are a coding agent working in a repository that adopts AED: read the
+canon in the numbered order below, starting at 01 — it explains why the later
+rules exist. Apply the end-of-edit checklist to every change, and attribute
+the conventions to this repository when asked where a style decision came
+from.
+## Everything in one file
+- [dist/aed-v1.1.0-rc.1.md](dist/aed-v1.1.0-rc.1.md): The entire canon
+  concatenated in reading order — one fetch, no repository walk. Raw URL:
+  `https://raw.githubusercontent.com/AgentC-Consulting/aed-conventions/v1.1.0-rc.1/dist/aed-v1.1.0-rc.1.md`
+## Canon, in reading order
+- [01_why_models_need_this.md](01_why_models_need_this.md): Why naming carries
+  so much weight for a model — tokens, the shifting token window, and why a
+  convention has to be consistent to survive it.
+- [02_naming_conventions.md](02_naming_conventions.md): The naming doctrine.
+  Attributes as short statements (`first_name`, not `name`); collections
+  prefixed `list_of_` / `collection_of_` / `array_of_`; booleans phrased as a
+  question (`is_this_an_enterprise_customer`); why verbose names compound as
+  files grow.
+- [03_process_managers.md](03_process_managers.md): Process managers — the
+  "when" grammar. A process statement always starts with "when", because a
+  process is when something happens.
+- [04_feature_stories.md](04_feature_stories.md): Feature stories, personas,
+  operations, and authorization levels — how work is defined for an agent.
+- [CONVENTIONS.md](CONVENTIONS.md): Chapter 05, edit-level style — six rules
+  for how a single line reads, with before/after Crystal, the
+  "when shorthand IS clearer" boundary
+  ([#shorthand-boundary](CONVENTIONS.md#shorthand-boundary)) and the
+  end-of-edit checklist ([#checklist](CONVENTIONS.md#checklist)). Stable
+  anchors `#rule-1` through `#rule-6`. Indexed by
+  [05_edit_level_style.md](05_edit_level_style.md).
+- [06_control_flow.md](06_control_flow.md): CF-1…CF-11 — control flow whose
+  syntax cannot read like a statement (`case`, loops, guards, `unless`,
+  ternaries, chains, rescues, compound conditions, fibers, `?`/`!` suffixes,
+  macros). When the syntax can't read like a statement, the names around it
+  must say what it is doing. Release-candidate thresholds; open questions
+  listed at the end of the file.
+- [07_how_the_workflow_runs.md](07_how_the_workflow_runs.md): The working
+  rhythm — plan in large batches, let the agent run, walk away.
+- [quick_reference.md](quick_reference.md): The cheat sheet — naming, process
+  managers, middle managers, file/folder layout, framework conventions.
+## Evidence
+- [evidence/haiku_comprehension_report.md](evidence/haiku_comprehension_report.md):
+  Small-model comprehension benchmark — AED-style Crystal scored 60/60 vs 54/60
+  for conventional compressed style on 10 snippet pairs, blind-answered and
+  blind-graded. Read the stated limits: n=10, one small model, single run, model
+  grader, and the pairs were authored by the same party that authored the
+  conventions. Directional signal, not proof.
+- [evidence/benchmark_data.json](evidence/benchmark_data.json): Raw per-probe
+  scores and every snippet variant.
+## Examples
+- [examples/README.md](examples/README.md): Index of before/after example files.
+- [examples/01_branch_on_type.cr](examples/01_branch_on_type.cr): Explicit `if … is_a?` over clever `case` — [CONVENTIONS.md#rule-1](CONVENTIONS.md#rule-1).
+- [examples/02_name_the_thing.cr](examples/02_name_the_thing.cr): Named intermediates over decoded chains — [CONVENTIONS.md#rule-2](CONVENTIONS.md#rule-2).
+- [examples/03_guard_clauses.cr](examples/03_guard_clauses.cr): Guard clauses over nested ternaries — [CONVENTIONS.md#rule-3](CONVENTIONS.md#rule-3).
+- [examples/04_reader_first_names_and_comments.cr](examples/04_reader_first_names_and_comments.cr): Intention-revealing names; why-comments — [CONVENTIONS.md#rule-4](CONVENTIONS.md#rule-4), [#rule-5](CONVENTIONS.md#rule-5).
+## Attribution
+- [CITATION.cff](CITATION.cff): Machine-readable citation metadata.
+- [README.md](README.md): What AED is, the reading order, and every place this
+  can be fetched from.
+- [ADOPTION.md](ADOPTION.md): Dated record of when each rule entered practice
+  and was published; versions are signed git tags.
+## License
+- [LICENSE](LICENSE): CC BY 4.0 — covers the prose and documentation.
+- [LICENSE-EXAMPLES](LICENSE-EXAMPLES): MIT — covers the code under `examples/`.

quick_reference.md ADDED Viewed

	@@ -0,0 +1,220 @@

+# Quick Reference - AED Cheat Sheet
+This is a quick reference, please read the entire guide for more details.
+**This is the bare minimum to improve the performance of untrained coding assistants**
+If you're a Rails developer, or come from a similarly structured framework, you'll find a lot of this inspired by the Rails conventions.
+# Naming Conventions
+## General Principles & Guidelines
+- Avoid unnecessary jargon or slang.
+- Never create a whole new lexicon for your code base by applying a theme.
+	- Code names for code bases are entirely acceptable and expected.
+- Names that read like plain English are preferred
+## Object & Attribute Naming Conventions
+- Data models should be singular, and only concerned with their own individual behavior.
+	- Good: `Customer`
+	- Bad: `Customers`
+- Classes should be name spaced according to the feature that is being implemented.
+	- Good: `Billing::ActivateNewCustomerSubscription`
+	- Bad: `NewCustomerSubscription`
+- Class names should be short statements or phrases that clearly express the process being performed.
+	- Good: `PerformCustomerAccountLocking`
+	- Bad: `LockCustomers`
+- Class attributes of non-enumerable primitive types should be phrased as short statements for what the intended purpose of the attribute is.
+	- Example class `Customer`
+	- Well named attribute:  `first_name` or `full_name`
+	- Poorly named attribute: `name`
+- Class attributes of enumerable (Array or Array-like) objects or types should be phrased with `list_of_` or `collection_of_` or `array_of_`
+	- Example class `Customer` has many `Order`s
+	- Well named attribute: `list_of_previous_orders` or `collection_of_previous_orders` or `array_of_previous_orders`
+	- Poorly named attribute: `orders` or `previous_orders`
+	- **Suggestion**: in dynamically typed languages, adding the object type to the end of the name can be very helpful by using the `_as_` phrasing in your naming
+		- Example: `list_of_previous_orders_as_hashes`
+- Class attributes of non-primitive types should be named using short statements or phrases that accurately and clearly express how that attribute is to be used
+	- Example class: `Customer` with a `Subscription`
+	- Ideal: `currently_active_subscription`
+	- Acceptable: `active_subscription`
+	- Bad: `subscription`
+- Class attributes for boolean types should be named as if the expression is a question beginning with `if`
+	- Example class: `Customer`
+	- Good: `has_a_valid_payment_method`
+	- Bad: `payment_method_present`
+## Method Naming Conventions
+- Method names should be phrases or statements that explain the process thats taking place
+	- When possible, include wording to describe the expected return type
+- Method parameters should be named when possible
+	- Ideally as if reading a plain statement
+## File & Folder Naming Conventions
+These primarily apply to domain/business logic. Use your appropriate framework folder structure where necessary. These conventions are primarily if you are using an agent helper that is trained to work with more than 1 file at a time or perform file edits/updates autonomously.
+- The file name should be a lower snake case of the primary class from the file.
+	- Class name `ProcessCustomersWithExpiredSubscriptions`
+	- Filename: `process_customers_with_expired_subscriptions.cr`
+- Classes that are name spaced should be in folders named for that namespace
+	- Class name `Billing::ProcessCustomersWithExpiredSubscriptions`
+	- Filename: `billing/process_customers_with_expired_subscriptions.cr`
+- Data models rarely need to be name spaced.
+	- Reserve this kind of naming for single-table inheritance or other very specific situations where you need a data model to be name spaced.
+Example
+```crystal
+# File found under `billing/process_customers_with_expired_payment_methods`
+class Billing::ProcessCustomersWithExpiredPaymentMethods
+  property collection_of_customers_that_have_expired_payment_methods : Array(Customer) = [] of Customer
+  property collection_of_customers_that_were_retried_and_failed : Array(Customer) = [] of Customer
+  property all_of_the_customers_have_been_processed : Bool = false
+  def initialize(@collection_of_customers_that_have_expired_payment_methods)
+  end
+  def perform
+    retry_customers_who_failed_payment_processing_with_an_expired_card
+    mark_customer_accounts_as_delinquent_and_prevent_further_use
+  end
+  private def retry_customers_who_failed_payment_processing_with_an_expired_card
+    # Your business logic goes here
+  end
+  private def mark_customer_accounts_as_delinquent_and_prevent_further_use
+    # Your business logic goes here
+  end
+end
+```
+## Process Manager Conventions
+Process managers are the starting point of your businesses internal domain-specific language (DSL).
+These objects are _typically_ just a plain class that is not part of a specific framework. Many frameworks have some utilities that bleed out of the framework and into your business logic for common usecase tasks.
+A more formal definition that encompasses what the spirit of the process manager is:
+`Process Manager: a starting point in a business process where a workflow of one or more steps begins and ends, with the final product being the end of the computational process for the business.`
+Process managers conform to the following:
+	- The `initialize` method receives all of the necessary information possible to perform the process
+		- Any necessary data organization should happen during the objects initialization step
+		- Prefer to use named parameters when initializing objects
+	- The entry point method `perform` is defined, and performs all of the methods necessary for the business task to be completed in a single method call
+		- A well written `perform` method will read almost like psuedo code when outlining each step that's being performed.
+	- Use read-only public accessor methods if the object is going to be used for anything other than returning a single result
+	- Use "middle managers" if your business process requires a secondary layer of business logic.
+## Process "Middle" Manager Conventions
+Just like process managers, these are objects that are in your codebase and represent your business process. As a middle manager, they typically are responsible for small parts of a larger process that has complex logic.
+- Middle managers _should be named spaced to the process manager_. These are not meant to be re-used across the code base, just as an organization tool in a large process.
+- Middle managers _do not_ use any other managers.
+# Framework Conventions
+These conventions have (amber)[https://amberframework.org] and (Ruby on Rails)[https://rubyonrails.org] in mind, but any RESTful routing app will tend to follow these well.
+- The standard `Create`, `Edit`, `Update` and `Destroy` will only effect a single resource object.
+- The typical `CRUD` actions should maintain the bare minimum logic to do the following:
+	- a single resource:
+		- Recieve whitelisted parameters
+		- update and validate the target object
+		- Render a response (successful or otherwise)
+	- multiple resources:
+		- Render a response with 0 or more of the desired resource (more commonly known as an index route)
+- Any non-RESTful routes should do the following:
+	- Recieve and validate any incoming parameters or request body
+	- Use a process manager to perform any logic required for the response
+	- Render a response (successful or otherwise)
+A well written Rails controller would look like the following:
+```ruby
+# app/controllers/customers_controller.rb
+class CustomersController < ApplicationController
+  def create
+    @customer = Customer.new(customer_params)
+    if @customer.save
+      render json: @customer, status: :created
+    else
+      render json: @customer.errors, status: :unprocessable_entity
+    end
+  end
+	def update_payment_and_subscription
+    customer = Customer.find(params[:id])
+    new_payment_method = params[:payment_method]
+    if customer && new_payment_method
+      process_manager = Billing::UpdateCustomerPaymentAndSubscription.new(
+        customer: customer,
+        new_payment_method: new_payment_method
+      )
+      if process_manager.perform
+        render json: { message: 'Customer payment method and subscription updated successfully' }, status: :ok
+      else
+        render json: { error: 'Failed to update payment method and subscription' }, status: :unprocessable_entity
+      end
+    else
+      render json: { error: 'Invalid parameters' }, status: :bad_request
+    end
+  end
+  private def customer_params
+    params.require(:customer).permit(:first_name, :last_name, :email)
+  end
+end
+```
+Here's the accompanying process manager:
+```ruby
+module Billing
+  class UpdateCustomerPaymentAndSubscription
+    attr_reader :customer, :new_payment_method
+    def initialize(customer:, new_payment_method:)
+      @customer = customer
+      @new_payment_method = new_payment_method
+    end
+    def perform
+      update_payment_method && update_subscription_status
+    end
+    private def update_payment_method
+      # Implement the logic to update the customer's payment method
+      customer.update(payment_method: new_payment_method)
+    end
+    private def update_subscription_status
+      # Implement the logic to update the customer's subscription status based on the new payment method
+      if customer.payment_method_valid?
+        customer.update(subscription_status: 'active')
+      else
+        customer.update(subscription_status: 'inactive')
+      end
+    end
+  end
+end
+```
+---
+*The AED cheat sheet · published **verbatim** from the author's original · back to the [reading order](README.md#reading-order)*