Multi-Agent Coding: One Agent Writes Tests, Another Writes the Code

# Spec: Password Validator

A password is valid if:
- At least 8 characters long
- Contains at least one uppercase letter
- Contains at least one digit
- Does not contain spaces

import anthropic

def run_test_writer_agent(spec: str) -> str:
    client = anthropic.Anthropic()

    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=1024,
        system="""You are a test-writing agent. 
You receive a software specification and write pytest tests for it.
Output ONLY valid Python test code. No explanations.
Do not write any implementation — only tests.""",
        messages=[
            {"role": "user", "content": f"Write tests for this spec:\n\n{spec}"}
        ]
    )

    return response.content[0].text

import pytest
from validator import is_valid_password

def test_minimum_length():
    assert not is_valid_password("Ab1")

def test_exact_minimum_length():
    assert is_valid_password("Abcdef1g")  # 8 chars, meets all rules

def test_missing_uppercase():
    assert not is_valid_password("abcdefg1")

def test_missing_digit():
    assert not is_valid_password("Abcdefgh")

def test_contains_space():
    assert not is_valid_password("Abcdef 1")

def test_empty_string():
    assert not is_valid_password("")

def test_all_uppercase_no_digit():
    assert not is_valid_password("ABCDEFGH")

def run_coder_agent(test_code: str) -> str:
    client = anthropic.Anthropic()

    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=1024,
        system="""You are a coding agent.
You receive pytest tests and write the implementation that passes them.
Output ONLY valid Python implementation code. No test code. No explanations.""",
        messages=[
            {"role": "user", "content": f"Write the implementation for these tests:\n\n{test_code}"}
        ]
    )

    return response.content[0].text

# validator.py

def is_valid_password(password: str) -> bool:
    if len(password) < 8:
        return False
    if " " in password:
        return False
    if not any(c.isupper() for c in password):
        return False
    if not any(c.isdigit() for c in password):
        return False
    return True

import os

def main():
    # Load spec
    with open("spec.md") as f:
        spec = f.read()

    print("Agent A: Writing tests...")
    test_code = run_test_writer_agent(spec)

    # Save tests
    with open("test_validator.py", "w") as f:
        f.write(test_code)
    print("Tests written to test_validator.py")

    print("\nAgent B: Writing implementation...")
    impl_code = run_coder_agent(test_code)

    # Save implementation
    with open("validator.py", "w") as f:
        f.write(impl_code)
    print("Implementation written to validator.py")

    # Run tests automatically
    print("\nRunning pytest...")
    os.system("pytest test_validator.py -v")

if __name__ == "__main__":
    main()

python orchestrator.py

def run_coder_agent_with_retry(test_code: str, max_retries: int = 3) -> str:
    client = anthropic.Anthropic()
    messages = [
        {"role": "user", "content": f"Write the implementation for these tests:\n\n{test_code}"}
    ]

    for attempt in range(max_retries):
        response = client.messages.create(
            model="claude-opus-4-6",
            max_tokens=1024,
            system="You are a coding agent. Output ONLY valid Python implementation code.",
            messages=messages
        )
        impl = response.content[0].text

        # Write and test
        with open("validator.py", "w") as f:
            f.write(impl)

        result = os.popen("pytest test_validator.py 2>&1").read()

        if "passed" in result and "failed" not in result:
            return impl  # All tests pass

        # Feed failure back to Agent B
        messages.append({"role": "assistant", "content": impl})
        messages.append({"role": "user", "content": f"Tests failed:\n{result}\n\nFix the implementation."})

    return impl  # Return last attempt