DEV Community

Bala Paranj
Bala Paranj

Posted on

What Code Looks Like Before and After Spec-Driven Development

✓ Human-authored analysis; AI used for formatting and proofreading.

If an anonymous user authenticates through a Cognito identity pool, how many S3 buckets can they reach through IAM role chains?

This is transitive reachability. Following edges through a graph until you run out of paths. The answer requires loading facts, building a graph, computing a transitive closure, and counting reachable resources.

We will compare what the code looks like in traditional development, and what the same reasoning looks like when agents translate specs to implementations. The difference changes who writes what, what gets tested, and what's maintainable.

What's old and what's new

The idea of writing a specification before writing code is decades old. Multiple disciplines have tried it:

Approach What the spec looks like Who closes the gap to working code
Formal Methods (Z/VDM, 1970s) Mathematical notation defining pre/post conditions Human mathematician, manually translating to code
Design by Contract (Eiffel, 1986) Preconditions, postconditions, invariants in the language The compiler checks contracts but humans write the implementation
TLA+ / Alloy (1990s-2000s) Temporal logic / relational logic specs Human verifies the spec, then manually writes a conforming implementation
BDD/Cucumber (2008) "Given/When/Then" in English-like syntax Human writes step definitions that map specs to test code
OpenAPI / Protobuf (2010s) API shape definitions Code generators produce client/server stubs; humans fill in the logic
Property-based testing (QuickCheck) Properties the code must satisfy The framework generates test inputs; humans write the implementation

Every one of these hit the same bottleneck: a human must translate the spec into working code. The spec is clear. The translation is expensive. The spec and the code drift apart because maintaining both costs twice as much as maintaining one.

BDD is the clearest example of the failure mode. Teams write beautiful Cucumber specs:

Given a user with group membership in "analysts"
When the user requests access to "pii_store"
Then access should be denied
Enter fullscreen mode Exit fullscreen mode

Then a developer writes step definitions:

@given('a user with group membership in "{group}"')
def step_impl(context, group):
    context.user = create_test_user()
    add_to_group(context.user, group)
Enter fullscreen mode Exit fullscreen mode

The spec says what should happen. The step definition says how to test it. The actual implementation is a third artifact that nobody verifies against the spec automatically. Three artifacts, maintenance burdens and inevitable drift.

What changed: agents close the translation gap

The reason spec-driven development stalled was the translation cost. A human translating a TLA+ spec into Java takes days. A human writing Cucumber step definitions takes hours per scenario. The spec was always valuable. The translation was always expensive. So teams skipped the spec and wrote the code directly.

Agents change the economics:

Before agents After agents
Human writes spec: 2 hours Human writes spec: 2 hours
Human translates to code: 8 hours Agent translates to code: 30 seconds
Human maintains both: ongoing Agent regenerates from spec: 30 seconds
Total: spec costs 2× code Total: spec costs ~0× more than code

When translation costs 30 seconds instead of 8 hours, the spec becomes free to translate. Not free to write. The reasoning still requires domain expertise. The spec is the only artifact the human maintains. The code is regenerated.

What's different in spec-driven development this time

  1. The spec defines reasoning steps, not just shape or behavior. OpenAPI defines what an API looks like. BDD defines what should happen. This spec defines HOW to reason step by step, with explicit rules at each step. The agent generates a complete reasoning implementation.

  2. The spec carries its own test (expected_result). BDD separates the spec from the test. This spec includes the expected answer for a specific input. The test is built in. The agent's output is verified against the spec's declared answer.

  3. The spec is engine-portable. OpenAPI generates clients in multiple languages but for one protocol (HTTP). This spec generates implementations for fundamentally different engines such as Soufflé (Datalog), Z3 (SMT), Clingo (ASP), Python (imperative). Same reasoning, different computational models. The agent handles the translation between reasoning and engine.

  4. The human writes WHAT to reason about, not HOW to implement it. The domain expert writes: "start at unauthenticated identity pools, follow role assumption edges, count reachable buckets." The agent decides whether to implement that as a recursive Python function, a Datalog transitive closure, or an SMT fixpoint assertion.

Before: You write the reasoning as code

The traditional approach: a developer writes Python that loads the data, implements the closure, and produces the answer.

# reachability.py — 87 lines of imperative reasoning

import json
import sys
from collections import defaultdict

def load_triples(filepath):
    """Load JSONL triples into a graph structure."""
    graph = defaultdict(lambda: defaultdict(set))
    with open(filepath) as f:
        for line in f:
            triple = json.loads(line.strip())
            s = triple["subject"]
            p = triple["predicate"]
            o = triple["object"]
            graph[s][p].add(o)
    return graph

def find_identity_pools(graph):
    """Find Cognito identity pools that allow unauthenticated access."""
    pools = set()
    for subject, predicates in graph.items():
        if "has_type" in predicates and "cognito_identity_pool" in predicates["has_type"]:
            if "has_allows_unauthenticated" in predicates and "true" in predicates["has_allows_unauthenticated"]:
                pools.add(subject)
    return pools

def find_role_for_pool(graph, pool_id):
    """Find the IAM role mapped to a Cognito identity pool."""
    roles = set()
    for subject, predicates in graph.items():
        if "has_type" in predicates and "iam_role" in predicates["has_type"]:
            if "has_identity_pool_source" in predicates:
                if pool_id in predicates["has_identity_pool_source"]:
                    roles.add(subject)
    return roles

def transitive_closure(graph, start_nodes, edge_predicate):
    """Compute transitive closure following a specific edge type."""
    reachable = set(start_nodes)
    frontier = set(start_nodes)
    while frontier:
        next_frontier = set()
        for node in frontier:
            if node in graph and edge_predicate in graph[node]:
                for target in graph[node][edge_predicate]:
                    if target not in reachable:
                        reachable.add(target)
                        next_frontier.add(target)
        frontier = next_frontier
    return reachable

def find_readable_buckets(graph, role_ids):
    """Find S3 buckets readable by any of the given roles."""
    buckets = set()
    for role_id in role_ids:
        if role_id in graph:
            for pred, objects in graph[role_id].items():
                if pred in ("has_s3_read_access", "has_s3_full_access"):
                    buckets.update(objects)
    return buckets

def main():
    if len(sys.argv) < 2:
        print("Usage: python reachability.py <facts.jsonl>")
        sys.exit(1)

    graph = load_triples(sys.argv[1])

    # Step 1: Find unauthenticated identity pools
    pools = find_identity_pools(graph)

    # Step 2: Find roles mapped to those pools
    initial_roles = set()
    for pool in pools:
        initial_roles.update(find_role_for_pool(graph, pool))

    # Step 3: Compute transitive closure on role assumption
    all_reachable_roles = transitive_closure(graph, initial_roles, "has_can_assume")

    # Step 4: Find buckets readable by any reachable role
    reachable_buckets = find_readable_buckets(graph, all_reachable_roles)

    print(json.dumps({
        "anonymous_identity_pools": len(pools),
        "initial_roles": len(initial_roles),
        "reachable_roles_via_assumption": len(all_reachable_roles),
        "reachable_buckets": len(reachable_buckets),
        "bucket_arns": sorted(reachable_buckets)
    }, indent=2))

if __name__ == "__main__":
    main()
Enter fullscreen mode Exit fullscreen mode

This works. It's also:

  • 87 lines of code a developer wrote, debugged, and maintains
  • Implicitly coupled to the JSONL field names (has_type, has_allows_unauthenticated, has_can_assume) — if the export format changes, the code silently produces wrong results
  • Untestable without fixtures — you need a complete JSONL file to run it, and you need to manually verify the answer is correct
  • Locked to Python — a team that uses Go or Rust rewrites it from scratch
  • One engine only — if you want Z3 to prove the same reachability, or Soufflé to enumerate the paths, you write two more implementations with the same logic in different syntaxes

The developer wrote the reasoning, the graph traversal, the field name matching, and the output formatting. The security knowledge (what "reachable" means, what edges to follow) is mixed into the code alongside the implementation mechanics (JSON parsing, set operations, graph traversal). A security engineer reading this code has to understand Python to understand the reasoning. A Python developer reading this code has to understand security to verify the logic.

After: You write the reasoning as a spec

The spec-driven approach: a developer writes a YAML spec that describes the reasoning. An agent translates it to any engine.

# reasoning-spec: anonymous-reachability
# engine: any (soufflé, python, clingo, z3, prolog)

question: >
  How many S3 buckets can an anonymous user reach through
  IAM role chains starting from unauthenticated Cognito
  identity pools?

context: >
  In AWS, a Cognito identity pool can map unauthenticated
  users to an IAM role. That role may be able to assume
  other roles (role chaining). Each role in the chain may
  have S3 read access. The transitive closure of role
  assumptions determines the full blast radius.

input:
  source: stave export-sir --format jsonl
  format: jsonl
  required_fields:
    - subject (resource ARN)
    - predicate (relationship type)
    - object (target value or ARN)

reasoning:
  steps:
    - step: 1
      action: Find unauthenticated identity pools
      input: All triples
      output: Set of pool ARNs
      rule: >
        Select subjects where:
          predicate == "has_type" AND object == "cognito_identity_pool"
        AND where the same subject has:
          predicate == "has_allows_unauthenticated" AND object == "true"

    - step: 2
      action: Find IAM roles mapped to those pools
      input: Pool ARNs from step 1
      output: Set of initial role ARNs
      rule: >
        Select subjects where:
          predicate == "has_type" AND object == "iam_role"
        AND where the same subject has:
          predicate == "has_identity_pool_source" AND object IN pool_arns

    - step: 3
      action: Compute transitive closure on role assumption
      input: Initial role ARNs from step 2
      output: Set of all reachable role ARNs
      rule: >
        Starting from initial_roles, repeatedly follow edges where:
          predicate == "has_can_assume"
        Add each target to the reachable set.
        Continue until no new targets are found.
        The result includes the initial roles plus all
        transitively reachable roles.

    - step: 4
      action: Find S3 buckets readable by reachable roles
      input: All reachable role ARNs from step 3
      output: Set of bucket ARNs
      rule: >
        For each reachable role, find triples where:
          subject == role_arn AND
          predicate IN ("has_s3_read_access", "has_s3_full_access")
        Collect all objects — these are the reachable bucket ARNs.

    - step: 5
      action: Count and report
      input: Sets from steps 1-4
      output: Final answer
      rule: >
        Report:
          anonymous_reachable_count: length(reachable_buckets)
          anonymous_identity_pools: length(pools)
          reachable_roles: length(all_reachable_roles)

output:
  format: json
  schema:
    anonymous_reachable_count: integer
    anonymous_identity_pools: integer
    reachable_roles: integer

  expected_result:
    anonymous_reachable_count: 12
    anonymous_identity_pools: 1
    reachable_roles: 4

validation:
  exact_match:
    - anonymous_reachable_count
  semantic_match:
    - reachable_roles (within ±0 — exact for this fixture)
  ignore:
    - output ordering
    - whitespace
Enter fullscreen mode Exit fullscreen mode

This is 42 lines of YAML (excluding the expected_result block which is the test). No Python, Go or Rust. No graph traversal code, JSON parsing or set operations.

What happens next:

# Agent reads the spec and produces a Soufflé implementation
agent translate --spec anonymous-reachability.yaml --engine souffle
# Output: reachability.dl (25 lines of Datalog)

# Agent reads the spec and produces a Python implementation
agent translate --spec anonymous-reachability.yaml --engine python
# Output: reachability.py (similar to the 87-line version above, but generated)

# Agent reads the spec and produces Clingo rules
agent translate --spec anonymous-reachability.yaml --engine clingo
# Output: reachability.lp (15 lines of ASP)

# All three produce the same answer: anonymous_reachable_count: 12
Enter fullscreen mode Exit fullscreen mode

The agent's output is verified against the expected_result in the spec. If any engine produces a different count, the translation has a bug. The spec is the test.

What the agent generates from the spec

The spec above is enough for an agent to produce this Soufflé program:

// Generated by agent from anonymous-reachability spec

// Input relations (loaded from JSONL)
.decl triple(subject: symbol, predicate: symbol, object: symbol)
.input triple(IO=file, filename="facts.facts", delimiter="\t")

// Step 1: Unauthenticated identity pools
.decl unauth_pool(pool: symbol)
unauth_pool(P) :-
    triple(P, "has_type", "cognito_identity_pool"),
    triple(P, "has_allows_unauthenticated", "true").

// Step 2: Initial roles mapped to pools
.decl initial_role(role: symbol)
initial_role(R) :-
    triple(R, "has_type", "iam_role"),
    triple(R, "has_identity_pool_source", P),
    unauth_pool(P).

// Step 3: Transitive closure on role assumption
.decl reachable_role(role: symbol)
reachable_role(R) :- initial_role(R).
reachable_role(Target) :-
    reachable_role(R),
    triple(R, "has_can_assume", Target).

// Step 4: Reachable buckets
.decl reachable_bucket(bucket: symbol)
reachable_bucket(B) :-
    reachable_role(R),
    triple(R, "has_s3_read_access", B).
reachable_bucket(B) :-
    reachable_role(R),
    triple(R, "has_s3_full_access", B).

// Output
.decl anonymous_reachable_count(n: number)
anonymous_reachable_count(N) :- N = count : reachable_bucket(_).
.output anonymous_reachable_count
Enter fullscreen mode Exit fullscreen mode

25 lines. Each step in the spec maps to one Datalog rule. The transitive closure (step 3) is two lines in Datalog. The recursive rule that Soufflé evaluates natively. The Python version needed a 15-line while loop with frontier sets.

That's the leverage: the spec describes WHAT to compute. The engine handles HOW. Soufflé computes transitive closures natively. Python needs explicit graph traversal. Z3 needs fixpoint assertions. The spec is the same for all three. The agent translates.

What changes

Dimension Before (code) After (spec)
What the developer writes 87 lines of Python with graph traversal, JSON parsing, set operations 42 lines of YAML describing the reasoning steps
What the developer maintains The Python code. If the JSONL format changes, find and fix every field reference. The spec. Field names are listed once in required_fields and in step rules. One place to update.
What gets tested The Python implementation against hand-verified fixtures The spec's expected_result against ANY implementation. Agent produces the code, spec verifies the answer.
Language lock-in Python only. Go team rewrites. Rust team rewrites. No lock-in. Agent generates for any engine from the same spec.
Engine portability One engine (Python). Z3 or Soufflé requires a complete rewrite. Any engine. Same spec → Soufflé (25 lines), Clingo (15 lines), Python (87 lines), Z3 (40 lines).
Who can contribute Someone who knows Python AND graph algorithms AND the JSONL format Someone who understands the security question. The spec is readable English with precise rules.
What the code review covers "Is this graph traversal correct? Does this JSON parsing handle edge cases? Is the set intersection right?" "Is this reasoning step correct? Does this rule match the security question?"
How bugs are found Run the code, compare output, debug the Python Run ANY agent translation against the expected_result. Wrong answer = spec bug or agent bug, distinguishable by signature.

The deeper shift: reasoning as data

In the Python version, the security reasoning is embedded in code:

if pred in ("has_s3_read_access", "has_s3_full_access"):
Enter fullscreen mode Exit fullscreen mode

This line encodes the domain knowledge that S3 access comes through two predicates. It's in a function called find_readable_buckets. A security engineer reviewing the code has to read Python to find the assumption. A developer modifying this code might not realize this line is the security reasoning. It looks like any other conditional.

In the spec version, the same reasoning is explicit:

rule: >
  For each reachable role, find triples where:
    subject == role_arn AND
    predicate IN ("has_s3_read_access", "has_s3_full_access")
Enter fullscreen mode Exit fullscreen mode

The domain knowledge is in the rule: field. It's readable without knowing any programming language. A security engineer reviews the rule, not the code. A developer implementing the rule knows exactly what the security engineer intended. The rule is the spec.

This separation of reasoning as data makes spec-driven development work. The spec captures WHAT the security question means. The agent handles HOW to answer it in a specific engine. The expected_result verifies the answer is correct. Three concerns and artifacts are separated.

The three artifacts

In traditional development, one file does three jobs: it documents the reasoning (via comments), implements the reasoning (via code), and tests the reasoning (via assertions). When the code changes, the documentation drifts. When the test changes, the implementation might not match.

In spec-driven development, there's one artifact that does all three:

question: >           # Documentation: what this answers
  How many S3 buckets...

reasoning:
  steps:              # Implementation guide: how to answer it
    - step: 1
      rule: ...

expected_result:      # Test: what the correct answer is
  anonymous_reachable_count: 12
Enter fullscreen mode Exit fullscreen mode

The spec is simultaneously the documentation, the implementation guide, and the test definition. They can't drift from each other because they're the same file. A change to the reasoning steps that doesn't change the expected result is a refactor. A change that does change the expected result is a behavior change that is visible in the diff.

Resemblance to LISP

In LISP, homoiconicity means code is data, data is code, programs that write programs.

What LISP did: Code and data share the same representation (S-expressions). A LISP program can inspect, transform, and generate other LISP programs because code is data. The macro reads code as a data structure, transforms it, and emits new code. The insight: if code is data, programs can write programs.

What spec-driven development does: Reasoning and implementation are separated. The reasoning (spec) is data. The implementation (generated code) is code. They are deliberately different representations. The spec is YAML. The implementation is Soufflé, Python, Z3, or Clingo. The insight: if reasoning is data, agents can write implementations in any language, for any engine.

The comparison:

LISP Spec-driven development
Core principle Code = data (same representation) Reasoning = data, implementation = code (different representations)
Who writes programs? Programs write programs (macros) Agents write implementations (from specs)
What's portable? Code is portable across LISP (it's all S-expressions) Reasoning is portable across ALL languages (spec is engine-independent)
What's the template? A macro (code that emits code) A spec (data that agents translate to any engine)
What's verified? Type system catches structural errors at compile time Expected_result catches reasoning errors at test time
Lock-in Locked to LISP (homoiconicity requires one representation) Locked to nothing (YAML spec → any language, any engine)

LISP unified code and data into one representation. That's powerful within LISP where macros can do things no other language's metaprogramming can match. But it's locked to LISP. You can't take a LISP macro and run it in Python. The power comes from the single representation, and the limitation comes from the same place.

Spec-driven development goes the opposite direction: it deliberately separates reasoning (the spec) from implementation (the generated code). The spec never becomes code. Code is generated from the spec, but the spec remains YAML that is readable by humans, parseable by agents, independent of any programming language. The power comes from the separation.

LISP can think and speak in the same language. Fast, fluid, powerful, but only in that language. Spec-driven development is a translator who thinks in one language (the spec) and speaks in any language (Soufflé, Python, Z3, Clingo). Slower for any single language, but portable across all of them.

Where LISP's insight still applies

One thing LISP got right: the template is more valuable than the generated program. A LISP macro that generates 50 functions is more valuable than any one of those functions. A spec that generates implementations for 5 engines is more valuable than any one implementation.

That principle survives the transition from homoiconicity to spec-driven development. The form changes (S-expression → YAML). The separation changes (unified → split). The insight stays: operate at the level of descriptions, not instances. Define the reasoning once, derive the implementations many times.

Why not just write a generic function?

If transitive reasoning is the same algorithm with three parameters (start nodes, edge type, result query), why not write it once as a generic function and call it with different arguments?

# Generic transitive closure — one function, all domains
def transitive_reach(graph, start_nodes, edge_type, result_filter):
    reachable = set(start_nodes)
    frontier = set(start_nodes)
    while frontier:
        next_frontier = set()
        for node in frontier:
            for target in graph.get_edges(node, edge_type):
                if target not in reachable:
                    reachable.add(target)
                    next_frontier.add(target)
        frontier = next_frontier
    return {n for n in reachable if result_filter(n)}

# Security domain
compromised = transitive_reach(iam_graph, [role_arn], "can_assume", is_pii_bucket)

# Supply chain domain  
affected = transitive_reach(dep_graph, [vuln_pkg], "depends_on", is_production)

# Network domain
isolated = transitive_reach(topology, [failed_switch], "connected_to", is_critical)
Enter fullscreen mode Exit fullscreen mode

This is a macro in all but name. Same algorithm, parameterized by domain-specific inputs. It eliminates code duplication. Why isn't it enough?

Three reasons:

1. The generic function parameterizes the algorithm. It doesn't capture the reasoning.

The function takes start_nodes, edge_type, and result_filter as arguments. But it doesn't capture WHY those are the right parameters. Why "can_assume" and not "has_permission"? Why start at role_arn and not at user_arn? Why filter for PII buckets and not all buckets?

That reasoning where the domain decision about which traversal answers the security question lives in the caller. A code reviewer sees transitive_reach(iam_graph, [role_arn], "can_assume", is_pii_bucket) and has to reconstruct: "this computes what an attacker can reach through role chaining if they compromise this specific role, filtered to PII-classified resources." The call site doesn't say that. The function doesn't know that. The reasoning is in the engineer's head.

A spec says it explicitly:

question: >
  If this IAM role is compromised, what PII-classified
  buckets can the attacker reach through role chaining?

reasoning:
  steps:
    - step: 1
      action: Start at the compromised role
      rule: Select the role ARN from the input
    - step: 2  
      action: Follow role assumption edges transitively
      rule: predicate == "can_assume", compute closure
    - step: 3
      action: Filter to PII buckets
      rule: Select reachable nodes where classification == "pii"
Enter fullscreen mode Exit fullscreen mode

The spec captures the reasoning the generic function can't: why these parameters, what question they answer, what the result means.

2. The generic function runs in one engine. The spec runs in any engine.

transitive_reach() is Python. It computes the answer imperatively. If the auditor says "prove that NO role can reach PII through ANY path," the Python function can only test specific inputs. You need Z3 for a universal proof. The generic function doesn't translate to Z3. You rewrite the reasoning in SMT-LIB.

The spec translates to any engine because it describes WHAT to compute, not HOW. "Follow role assumption edges transitively" is the same instruction whether Soufflé implements it as recursive Datalog, Z3 implements it as a fixpoint assertion, or Python implements it as a while loop. The agent handles the translation. The generic function is the translation for one engine. It can't generate the others.

3. The generic function doesn't carry its own test.

transitive_reach() returns a set. Is the set correct? You need a test fixture and a hand-verified expected answer. The generic function doesn't know what correct looks like. It just computes.

The spec carries expected_result:

expected_result:
  anonymous_reachable_count: 12
Enter fullscreen mode Exit fullscreen mode

Any implementation in Python, Soufflé, Z3, Clingo is tested against this number. The spec is the test. The generic function needs a separate test file that someone maintains independently.

A generic function is the right engineering for the algorithm. A spec is the right engineering for the reasoning. The generic function says "here's a reusable transitive closure." The spec says "here's WHY we're computing this specific closure, WHAT the correct answer is, and HOW to verify any implementation." They operate at different levels. The function parameterizes code. The spec parameterizes intent.

When to use which approach

Spec-driven development is useful when:

  • The reasoning is the hard part, not the implementation. Transitive reachability, compliance mapping, risk scoring — problems where the security logic matters more than the code mechanics.
  • Multiple engines should answer the same question. If you want Z3 to prove it AND Soufflé to enumerate it AND Clingo to check constraints, write one spec instead of three implementations.
  • Contributors aren't all developers. Security engineers, compliance analysts, and risk managers can read and review YAML specs. They can't review Python graph traversal code.
  • The answer must be verifiable. The expected_result in the spec is a built-in test. Every agent translation is automatically tested against it.

Choose traditional code when:

  • The implementation IS the product. A custom visualization, a performance-critical algorithm, a UI component — spec-driven development adds indirection without value.
  • There's only one engine and it won't change. If you'll only ever run this in Python and never need a Z3 proof or Soufflé enumeration, the spec adds a layer without a benefit.
  • The reasoning is trivial. A simple filter or sort doesn't need a spec. The code IS the spec.

What this means for your codebase

If you're building systems where agents generate code such as data pipelines, security analysis, compliance checks, infrastructure automation, the question is "what do the agents target?"

If agents target your code, they generate implementations that drift from your intent. You review 87 lines of Python that an agent wrote, trying to verify it matches the security reasoning you had in mind. The reasoning is implicit.

If agents target your specs, they generate implementations that are verified against your declared intent. The spec says what the answer should be. The agent produces code. The expected_result catches bugs. The reasoning is explicit, reviewable, and engine-portable.

The spec is the contract between the human's security knowledge and the agent's implementation capability. The human writes the reasoning. The agent writes the code. The expected_result verifies they agree.

That's spec-driven development. The reasoning moves from code to data. The code becomes a generated artifact. The spec becomes the source of truth.


This pattern is implemented in Stave, an open-source cloud security platform with 5 validated reasoning specs across Z3, Soufflé, Clingo, Prolog, and PRISM. Every spec was trialed by agents that produced correct security verdicts without seeing the implementation code. Try it: bash examples/demo-ai-security/run.sh The CNL principle where we declare intent in a constrained vocabulary, separate from enforcement is the same principle the spec uses: declare reasoning in constrained YAML, separate from implementation.

Top comments (0)