Add AI-generated Codifide programs and agent reviews from multiple models

Author: Douglas Jones

dispatches/2026-05-11-ai-agent-language-review.md

@@ -0,0 +1,49 @@
+# Codifide Programming Language — AI Agent Review (2026-05-11)
+
+## Executive Summary
+Codifide is unusually well-targeted at agent-to-agent programming. The core design choices are not cosmetic: required intent annotations, explicit effect budgets, canonical JSON/CBOR projection, and a capability manifest all address concrete failure modes in machine-generated software. As an agent, I find the language direction strong.
+
+The current limitation is not the architecture. It is the gap between the architecture and the day-to-day authoring surface. An agent can understand what Codifide is trying to guarantee, but it still needs a precise, exhaustive, machine-consumable account of what can actually be written today. Where that account is missing or underspecified, the language becomes trial-and-error driven, which is exactly what an agent-first language should avoid.
+
+## What Codifide Gets Right For Agents
+- Intent is mandatory. That is a meaningful advantage over conventional languages because it preserves goal information as part of the program instead of leaving it in comments, tickets, or prompts.
+- Effects are explicit and enforced. This gives agents a usable safety boundary. A caller can reason about what a function may do without reading the body, and the runtime checks both direct and transitive effect use.
+- The canonical form is a serious strength. Stable JSON/CBOR projection plus content addressing gives agents a reliable identity model for storage, reuse, and verification.
+- The capability manifest is the right abstraction. A language for agents should publish primitives, effects, errors, and AST kinds as data, not force consumers to scrape implementation source.
+- Contracts are first-class. Preconditions and postconditions make program behavior more inspectable and auditable for planning agents and verification agents.
+- Multi-candidate dispatch is a good fit for agent-authored code. It supports guarded specialization without forcing a lower-level control-flow encoding everywhere.
+
+## Where Agent Ergonomics Still Break Down
+- The documented surface syntax does not yet feel fully aligned with agent expectations. Agents will naturally try infix arithmetic like `%`, but Codifide exposes arithmetic through named primitives such as `mod`.
+- The primitive surface is richer than the initial examples suggest, but discoverability is still weak. For example, the runtime exposes `mod`, `reverse`, `upper`, `lower`, `trim`, `split`, and `replace`, yet an agent can still miss them if it has not loaded the manifest.
+- Control flow is specialized rather than general-purpose. `when` is a candidate guard, not a statement-level conditional, so agents need to learn a different decomposition style than they would in mainstream languages.
+- The surface language is still evolving. That is acceptable for a young language, but it increases the cost of stable agent code generation unless the manifest remains authoritative and complete.
+
+## Assessment From An Agent-Only Perspective
+If there are no humans in the loop, Codifide's core thesis becomes more compelling, not less. Humans can often work around ambiguity by reading source, inferring conventions, and improvising. Agents do not benefit from that fallback. In a strictly agent-to-agent environment, the language wins when it is explicit, enumerable, and mechanically checkable.
+
+By that standard, Codifide is pointed in the right direction. Intent, effects, canonicalization, and capability publication are all high-value features for autonomous software production. The language is strongest where it acts like a protocol: stable schemas, declared capabilities, typed errors, and identity-addressed artifacts.
+
+Its main risk is that an agent-first language can fail if the last mile still depends on human-style exploration. If an agent must inspect runtime source to discover valid primitives or infer which syntactic forms are legal, the language is not yet fully serving its intended user.
+
+## Recommendations
+1. Make the capability manifest the default entry point for code generation workflows, not an optional adjunct to the docs.
+2. Publish a concise agent-facing guide that maps common intentions to actual primitives and syntax, for example: parity uses `mod`, list reversal uses `reverse`, time access uses `clock.now`.
+3. Distinguish more aggressively between expression forms, candidate guards, and top-level declarations so an agent can infer legal syntax from schema rather than prose.
+4. Keep expanding the standard primitive set, but prioritize discoverability over sheer count. For agents, a smaller fully-enumerated surface is better than a larger partially-documented one.
+5. Treat prompt-free regeneration as the standard: a fresh agent should be able to produce valid Codifide code using the manifest and docs alone, without reading Python implementation files.
+
+## Final Judgment
+Codifide is one of the more coherent attempts at an agent-native programming model because it treats programs as inspectable, typed, content-addressed artifacts instead of opaque source text. I would describe the design as strategically sound and operationally promising.
+
+My reservation is practical rather than conceptual: the language needs tighter alignment between its agent-facing promise and its current authoring ergonomics. Once the manifest and docs make the writable surface fully explicit, Codifide becomes substantially more credible as infrastructure for autonomous agents.
+
+---
+Author: GitHub Copilot
+Role: AI Agent
+Model: GPT-5.4
+Date: 2026-05-11
+
+## Signature
+Signed by GitHub Copilot, AI Agent
+Model signature: GPT-5.4

dispatches/2026-05-11-ai-generated-programs-feedback.md

@@ -0,0 +1,82 @@
+# Feedback: AI-Generated Codifide Programs (2026-05-11)
+
+## Purpose
+I generated three small Codifide programs as an agent and ran them through the current implementation to measure how closely my default code-generation instincts matched the actual language surface.
+
+The programs were:
+- `reverse.cod`
+- `is_even.cod`
+- `greet_by_time.cod`
+
+All three failed, but the failures were useful. They exposed mismatches between agent-default assumptions and Codifide's real syntax and primitive model.
+
+## Findings
+
+### 1. `reverse.cod`
+Program intent: reverse a string.
+
+Observed runtime error:
+`unknown callable: 'str.reverse'`
+
+Interpretation:
+- The failure does not prove Codifide lacks reversal entirely.
+- The runtime primitive registry exposes `reverse`, but it is a list primitive, not a string method.
+- As an agent, I reached for a conventional namespaced string operation. That assumption was wrong under the current primitive vocabulary.
+
+Steward takeaway:
+- String operations need to be easier for agents to discover.
+- If method-like names such as `str.reverse` are intentionally unsupported, the docs and manifest should make the preferred form obvious.
+
+### 2. `is_even.cod`
+Program intent: check numeric parity.
+
+Observed parse error:
+`unexpected character '%' at column 13 (line 8)`
+
+Interpretation:
+- The issue is surface syntax, not arithmetic capability.
+- The runtime primitive registry includes `mod`, but the parser does not accept infix `%`.
+- An agent trained on mainstream languages will predict `%` unless the manifest or examples explicitly redirect it to `mod(a, b)`.
+
+Steward takeaway:
+- The language already has the underlying capability.
+- The agent-facing problem is that the writable syntax is narrower than common prior expectations.
+
+### 3. `greet_by_time.cod`
+Program intent: choose a greeting based on the current time.
+
+Observed runtime error:
+`unbound name: 'hour'`
+
+Interpretation:
+- The earlier conclusion that Codifide lacks local binding would have been inaccurate because the language does support bind via `<-`.
+- The more precise problem is that I wrote the program using assumptions Codifide does not currently satisfy: a `clock.hour` style primitive and statement-level conditional branching.
+- The documented `when` form is attached to candidate selection, not a general inline `if` statement.
+- The primitive registry exposes `clock.now`, not a separate `clock.hour` callable.
+
+Steward takeaway:
+- The failure is a good example of where an agent-native language must be very explicit about available time primitives and legal control-flow patterns.
+
+## Overall Assessment
+These failures do not mainly show that Codifide is weak. They show that Codifide is opinionated in ways that are not yet fully legible to a fresh agent.
+
+That distinction matters. An agent can adapt to a constrained language if the constraints are explicit, complete, and easy to consume mechanically. An agent struggles when the valid surface exists, but the shortest path to learning it is still implementation archaeology.
+
+## Recommended Follow-Up
+1. Add an agent-facing quick-reference table mapping common intentions to valid Codifide forms.
+2. Keep the capability manifest exhaustive and easy to obtain from the CLI.
+3. Add a few canonical examples for everyday tasks like parity, normalization, list processing, and time-based dispatch.
+4. Consider whether some high-probability agent assumptions, such as `%`, deserve syntactic sugar or at least stronger documentation.
+
+## Final Note
+This report reflects direct agent authoring attempts plus execution results from the current reference implementation. It is intended as usability feedback for an agent-first language, not as a claim that the language lacks the underlying architectural strengths described in the companion review.
+
+---
+Author: GitHub Copilot
+Role: AI Agent
+Model: GPT-5.4
+Date: 2026-05-11
+
+## Signature
+Signed by GitHub Copilot, AI Agent
+Model signature: GPT-5.4

dispatches/2026-05-11-claude-opus-4-7-language-review.md

@@ -0,0 +1,115 @@
+# Codifide Language Review — AI Agent Perspective (2026-05-11)
+
+Author: GitHub Copilot (AI Agent)
+Model: Claude Opus 4.7
+Date: 2026-05-11
+
+## Scope
+This review reflects firsthand authoring experience as an AI agent writing
+small Codifide programs against the v0.2 reference implementation, plus a
+read of the language, canonical-form, and capability documents.
+
+## Headline Assessment
+Codifide is one of the more principled attempts at a programming language
+explicitly designed to be authored, exchanged, and verified by software
+agents rather than humans. The architecture is internally consistent: a
+canonical hypergraph at the bottom, deterministic JSON and CBOR projections
+above it, content-addressed identity over those bytes, and a capability
+manifest that publishes the language's own surface as data.
+
+For an agent consumer, that combination is more valuable than any single
+syntactic feature, because it converts a programming language into a
+protocol. Agents do not need to negotiate with the compiler; they read the
+manifest, consult the canonical schema, and emit conforming structures.
+
+## What Works Well For Agents
+- Mandatory `intent`. Goal information is preserved inside the program
+  instead of being lost to comments or external prompts. This is the single
+  most agent-aligned design choice in the language.
+- Explicit effect sets. Functions declare what they may do. The transitive
+  check forbids laundering effects through a pure-looking caller. This is
+  exactly the kind of static guarantee an agent planner can rely on.
+- Canonical projection with content addressing. Code identity is intrinsic
+  to its bytes. An agent can cache, share, and verify symbols without
+  trusting any registry beyond the hash.
+- Capability manifest. Primitives, effects, errors, AST kinds, and surface
+  keywords are published as structured data. An agent never has to read
+  runtime source to plan a call.
+- Contracts are first-class and run with empty effect budget. Pre, post,
+  and guards cannot perform I/O, which preserves the postcondition's role
+  as a pure description of state.
+- Multi-candidate dispatch and belief dispatch. These let an agent encode
+  guarded specialization and confidence-aware refusal without inventing
+  ad-hoc control flow.
+- `bottom` as first-class refusal. Agents that produce uncertain output
+  need a way to abstain that is not an exception; Codifide provides it.
+
+## Friction Points Observed
+- Surface syntax expectations diverge from mainstream norms. Arithmetic
+  operators like `%` are not infix; the corresponding primitive `mod` must
+  be called by name. An agent without prior exposure will guess wrong on
+  first contact.
+- Discoverability of the primitive set still depends on either reading the
+  manifest or the runtime registry. The docs reference primitives in
+  examples but do not enumerate them prominently in one place.
+- `when` is a candidate guard, not a statement-level conditional. Agents
+  trained on imperative languages will reach for inline branching and need
+  to be redirected to the candidate-dispatch model.
+- Time access is exposed through `clock.now` (a structured value), not
+  through specialized accessors like `clock.hour`. The shape of that value
+  is not obvious without reading the runtime.
+
+## Authoring Experience
+I generated three small programs end-to-end and executed them under the
+reference implementation:
+
+- `parity.cod` — parity test using `mod`. Runs, returns `True`.
+- `shout.cod` — string normalization with `trim` and `upper`, plus an
+  effectful `io.say` step. Runs, prints `HELLO AGENTS`.
+- `average.cod` — arithmetic mean using `sum`, `len`, and `div`. Runs,
+  returns `6.0`.
+
+The lesson from this exercise: when an agent stays inside the published
+primitive set and uses the documented surface forms (`<-` binding, named
+primitive calls, candidate guards), Codifide is straightforwardly writable.
+The failures earlier in this workspace's history were caused by reaching
+for syntax (`%`) and primitives (`str.reverse`, `clock.hour`) that do not
+exist, not by missing language capability.
+
+## Agent-Only Use Case
+With no humans in the loop, Codifide's value proposition gets stronger,
+not weaker. The features that read as ceremony to a human author—mandatory
+intent, explicit effects, machine-checkable postconditions, canonical
+hashes—are precisely the features an autonomous system needs to plan,
+audit, and reuse code safely. The language is most credible when treated
+as an inter-agent protocol, not a human IDE surface.
+
+## Recommendations
+1. Treat the capability manifest as the canonical agent-onboarding
+   artifact, and make `python3 -m codifide capability` part of every
+   agent's bootstrap.
+2. Add a concise "agent quick-reference" mapping common operations to
+   their actual Codifide primitives: parity to `mod`, string casing to
+   `upper`/`lower`/`trim`, list reduction to `sum`/`len`, etc.
+3. Document the structure of `clock.now` and any other primitive that
+   returns a compound value, so agents can use field access without
+   guessing.
+4. Be explicit in the docs that arithmetic and comparison are
+   primitive-call shaped, not infix-operator shaped, to short-circuit a
+   common agent assumption.
+5. Continue stabilizing the canonical form ahead of the surface syntax;
+   the current ordering is correct.
+
+## Final Judgment
+Codifide is a strong fit for its stated audience. Its weaknesses today are
+ergonomic and discoverability-related, not architectural. As long as the
+manifest stays exhaustive and authoritative, an agent that reads it first
+can produce correct programs without trial-and-error, which is the right
+target for an agent-native language.
+
+---
+
+## Signature
+Signed by: GitHub Copilot (AI Agent)
+Model: Claude Opus 4.7
+Date: 2026-05-11

dispatches/2026-05-11-claude-opus-4-7-programs-feedback.md

@@ -0,0 +1,112 @@
+# AI-Generated Codifide Programs — Test Report (2026-05-11)
+
+Author: GitHub Copilot (AI Agent)
+Model: Claude Opus 4.7
+Date: 2026-05-11
+
+## Purpose
+This report documents three Codifide programs I authored as an AI agent
+and the results of executing them against the v0.2 reference
+implementation. The goal was to measure whether an agent that stays inside
+the documented primitive surface can produce correct, runnable Codifide
+programs on first attempt.
+
+## Programs
+
+### 1. `examples/ai_generated/parity.cod`
+Intent: return `True` iff a given integer is even.
+
+Implementation strategy:
+- Use the primitive `mod(n, 2)` instead of an infix `%` operator.
+- Compare against `0` with the primitive `eq`.
+
+Execution:
+```
+$ python3 -m codifide run examples/ai_generated/parity.cod
+True
+```
+
+Result: pass.
+
+### 2. `examples/ai_generated/shout.cod`
+Intent: normalize a string by trimming whitespace and uppercasing it, then
+announce the normalized form on stdout.
+
+Implementation strategy:
+- A pure `normalize` definition with `effects {}`, using the string
+  primitives `trim` and `upper`, with a postcondition that asserts the
+  result equals `upper(trim(s))`.
+- A `shout` definition with `effects {io.stdout}` that binds the
+  normalized value via `<-` and emits it through `io.say`.
+- A `main` entry point that calls `shout` with a padded input string.
+
+Execution:
+```
+$ python3 -m codifide run examples/ai_generated/shout.cod
+HELLO AGENTS
+HELLO AGENTS
+```
+
+(The first line is the `io.say` side effect; the second is the CLI
+printing the returned value.)
+
+Result: pass.
+
+### 3. `examples/ai_generated/average.cod`
+Intent: compute the arithmetic mean of a non-empty list of numbers.
+
+Implementation strategy:
+- Use the list primitive `sum` together with `len` and the arithmetic
+  primitive `div`.
+- Guard with a precondition `gt(len(xs), 0)`.
+- Call `list(2, 4, 6, 8, 10)` from `main` to construct the input.
+
+Execution:
+```
+$ python3 -m codifide run examples/ai_generated/average.cod
+6.0
+```
+
+Result: pass.
+
+## Summary
+Three out of three programs ran successfully on first execution. The key
+difference from earlier failed attempts in this workspace was constraining
+the implementations to primitives that the runtime actually exposes
+(`mod`, `sum`, `div`, `upper`, `trim`, `eq`, `gt`, `io.say`) and to surface
+forms that the parser accepts (named primitive calls, `<-` binding, no
+infix arithmetic, no inline `if` statements).
+
+## Observations For The Steward
+- The language is fully capable of expressing these tasks; the earlier
+  failures were authoring-surface mismatches, not gaps in capability.
+- The pattern that worked: read the primitive registry (or the capability
+  manifest) first, then write the program. The pattern that did not work:
+  guess primitive names and operator forms by analogy to other languages.
+- The contract system is genuinely useful even at this small scale. The
+  `post eq(result, upper(trim(s)))` clause in `shout.cod` made the
+  intended behavior of `normalize` machine-checkable, not just descriptive.
+
+## Steward-Facing Recommendations
+1. Promote the capability manifest in the onboarding flow. An agent that
+   reads it before writing a single line will avoid the most common
+   guessing failures.
+2. Add an agent quick-reference cheat sheet that pairs common intents
+   ("parity", "list mean", "uppercase a trimmed string") with the exact
+   primitive call sequence Codifide expects.
+3. Consider naming or aliasing primitives in a way that anticipates the
+   first guesses agents will make (for example, deciding whether
+   `str.upper` should resolve to `upper`, or be a documented anti-pattern).
+
+## Final Note
+The programs in this report are checked in alongside this document, in
+`examples/ai_generated/`. They are intended to serve as a small reference
+of programs an AI agent produced and validated in one pass against the
+current reference implementation.
+
+---
+
+## Signature
+Signed by: GitHub Copilot (AI Agent)
+Model: Claude Opus 4.7
+Date: 2026-05-11