Getting Started With AI Coding Agents: Autonomous Dev Guide

   mkdir ai_prime_checker
   cd ai_prime_checker
   ```
2. **Create and Activate Virtual Environment**:
```bash
   python -m venv venv
   # On macOS/Linux:
   source venv/bin/activate
   # On Windows:
   venv\Scripts\activate
   ```
3. **Install Dependencies**: Install `crewAI` and `python-dotenv` (for managing API keys securely).
```bash
   pip install crewai 'crewai[tools]' python-dotenv
   ```
The `'crewai[tools]'` part ensures that `crewAI` installs its default set of tools, which can be useful even if we're not explicitly using them in this simple example.

### Step 2: Configure your LLM API Key

For security and convenience, we'll store our API key in a `.env` file and load it using `python-dotenv`.

1. **Create `.env` file**: In your `ai_prime_checker` directory, create a file named `.env`.
2. **Add your OpenAI API Key**: Open `.env` and add your key:

import os
from crewai import Agent, Task, Crew, Process
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Ensure the OpenAI API key is set
if not os.getenv("OPENAI_API_KEY"):
    raise ValueError("OPENAI_API_KEY environment variable not set.")

# 1. Define the Agents
# Each agent has a role, goal, and backstory. This helps them stay in character.

researcher = Agent(
    role='Senior Research Analyst',
    goal='Identify efficient algorithms for prime number checking and listing, and pinpoint edge cases for testing.',
    backstory="""You are a seasoned Research Analyst with a deep understanding of mathematical algorithms and software development best practices.
                 Your expertise lies in breaking down complex problems and providing clear, actionable insights for developers.""",
    verbose=True,
    allow_delegation=False
)

coder = Agent(
    role='Senior Python Developer',
    goal='Write clean, efficient, and well-documented Python code for prime number operations based on research findings.',
    backstory="""You are an experienced Python Developer with a strong focus on writing robust, readable, and maintainable code.
                 You adhere to PEP 8 standards and prioritize type hints and comprehensive docstrings.""",
    verbose=True,
    allow_delegation=False
)

tester = Agent(
    role='Quality Assurance Engineer',
    goal='Develop comprehensive unit tests to ensure the correctness and robustness of the prime number functions.',
    backstory="""You are a meticulous QA Engineer with expertise in Python's `unittest` framework.
                 You are skilled at identifying edge cases and ensuring full test coverage for critical functions.""",
    verbose=True,
    allow_delegation=False
)

reviewer = Agent(
    role='Senior Code Reviewer',
    goal='Critique the developed code and tests, providing constructive feedback for improvements.',
    backstory="""You are a highly experienced Senior Code Reviewer, ensuring all code meets high standards of quality,
                 correctness, and adherence to requirements. You pay close attention to logic, style, and test coverage.""",
    verbose=True,
    allow_delegation=True # Allows reviewer to delegate back if issues are found
)

# 2. Define the Tasks
# Each task has a description, an expected output, and is assigned to an agent.

research_task = Task(
    description="""Research efficient algorithms for checking if a number is prime and for listing all prime numbers up to a given limit (N).
                   Identify common edge cases for these functions, such as 0, 1, negative numbers, small primes (2, 3), and larger numbers.
                   Summarize findings, including recommended algorithms and test cases.""",
    expected_output="""A detailed markdown report outlining efficient algorithms for primality testing and prime listing,
                       along with a comprehensive list of edge cases and test scenarios.""",
    agent=researcher
)

coding_task = Task(
    description="""Based on the research findings, develop a Python script named `prime_checker.py`.
                   This script must contain:
                   - A function `is_prime(n: int) -> bool` to check if a number is prime.
                   - A function `list_primes_up_to(n: int) -> list[int]` to list all prime numbers up to `n`.
                   - Both functions should include type hints, comprehensive docstrings, and basic error handling for non-integer inputs.
                   - The script should also have a `if __name__ == "__main__":` block demonstrating the usage of both functions.
                   Ensure the code is clean, efficient, and adheres to Python best practices (PEP 8).""",
    expected_output="""A complete, well-documented Python file named `prime_checker.py` containing the specified functions and main block.
                       The file should be ready to be executed and tested.""",
    agent=coder
)

testing_task = Task(
    description="""Create a Python script named `test_prime_checker.py` containing unit tests for the `is_prime` and `list_primes_up_to` functions
                   developed in `prime_checker.py`. Use Python's `unittest` module.
                   The tests must cover:
                   - Positive cases for both functions.
                   - Edge cases identified by the Research Analyst (e.g., 0, 1, 2, negative numbers, various small and medium primes).
                   - Error handling for invalid inputs.
                   Ensure tests are clear, isolated, and provide good coverage.""",
    expected_output="""A complete Python file named `test_prime_checker.py` with comprehensive unit tests for `prime_checker.py`.
                       The tests should pass successfully against the generated `prime_checker.py`.""",
    agent=tester
)

review_task = Task(
    description="""Review `prime_checker.py` and `test_prime_checker.py`.
                   Critique the code for:
                   - Correctness and adherence to requirements.
                   - Readability, style, and docstring quality.
                   - Efficiency of algorithms.
                   Critique the tests for:
                   - Coverage of requirements and edge cases.
                   - Correctness and effectiveness.
                   Provide a summary of findings and suggest any necessary improvements. If issues are found, delegate back to the coder/tester for fixes.""",
    expected_output="""A detailed review report indicating whether the code and tests meet requirements,
                       with specific suggestions for improvement if any issues are identified.
                       If no issues, state that the code is approved.""",
    agent=reviewer
)

# 3. Form the Crew
# Define the crew with agents and tasks, and the process flow.

project_crew = Crew(
    agents=[researcher, coder, tester, reviewer],
    tasks=[research_task, coding_task, testing_task, review_task],
    process=Process.sequential, # Tasks are executed in the order they are defined
    verbose=True,
    full_output=True # Get full output including generated files
)

# 4. Kick off the Crew
print("### Initiating the AI Prime Checker Project Crew ###")
result = project_crew.kickoff()

print("\n### Project Crew Finished ###")
print("\nFinal Output:")
# Access the full output, which includes generated files
# crewAI saves files to a 'results' directory by default if tools are used or if explicitly configured.
# For this example, the output will be printed to console, and we'll manually extract the code.
# In more advanced setups, agents can directly write to files using dedicated tools.

python run_crew.py

"""
This module provides functions to check for prime numbers and list primes up to a given limit.
"""

def is_prime(n: int) -> bool:
    """
    Checks if a given integer is a prime number.

    A prime number is a natural number greater than 1 that has no positive divisors
    other than 1 and itself.

    Args:
        n: An integer to be checked for primality.

    Returns:
        True if n is a prime number, False otherwise.
    """
    if not isinstance(n, int):
        raise TypeError("Input must be an integer.")
    if n < 2:
        return False
    # Check for divisibility from 2 up to the square root of n
    i = 2
    while i * i <= n:
        if n % i == 0:
            return False
        i += 1
    return True

def list_primes_up_to(n: int) -> list[int]:
    """
    Lists all prime numbers up to and including a given integer n.

    Args:
        n: The upper limit (inclusive) for listing prime numbers.

    Returns:
        A list of prime numbers up to n.
    """
    if not isinstance(n, int):
        raise TypeError("Input must be an integer.")
    if n < 2:
        return []

    primes = []
    # Using the Sieve of Eratosthenes for efficiency for larger N,
    # but for simplicity and smaller N, direct checking is often sufficient.
    # For this implementation, we'll use our is_prime function.
    for num in range(2, n + 1):
        if is_prime(num):
            primes.append(num)
    return primes

if __name__ == "__main__":
    print("--- Prime Checker Demonstration ---")

    # Test is_prime function
    test_numbers = [0, 1, 2, 7, 10, 17, 97, 100]
    for num in test_numbers:
        print(f"Is {num} prime? {is_prime(num)}")

    # Test list_primes_up_to function
    limit = 20
    print(f"\nPrimes up to {limit}: {list_primes_up_to(limit)}")

    limit = 1
    print(f"Primes up to {limit}: {list_primes_up_to(limit)}")

    # Demonstrate error handling
    try:
        is_prime(3.14)
    except TypeError as e:
        print(f"\nError handling test: {e}")

import unittest
from prime_checker import is_prime, list_primes_up_to

class TestPrimeChecker(unittest.TestCase):

    # --- Tests for is_prime function ---
    def test_is_prime_small_primes(self):
        self.assertTrue(is_prime(2))
        self.assertTrue(is_prime(3))
        self.assertTrue(is_prime(5))
        self.assertTrue(is_prime(7))

    def test_is_prime_small_non_primes(self):
        self.assertFalse(is_prime(0))
        self.assertFalse(is_prime(1))
        self.assertFalse(is_prime(4))
        self.assertFalse(is_prime(6))
        self.assertFalse(is_prime(9))

    def test_is_prime_medium_primes(self):
        self.assertTrue(is_prime(17))
        self.assertTrue(is_prime(97))

    def test_is_prime_medium_non_primes(self):
        self.assertFalse(is_prime(15))
        self.assertFalse(is_prime(100))

    def test_is_prime_negative_numbers(self):
        self.assertFalse(is_prime(-1))
        self.assertFalse(is_prime(-10))

    def test_is_prime_type_error(self):
        with self.assertRaises(TypeError):
            is_prime(3.14)
        with self.assertRaises(TypeError):
            is_prime("abc")

    # --- Tests for list_primes_up_to function ---
    def test_list_primes_up_to_small_limit(self):
        self.assertEqual(list_primes_up_to(1), [])
        self.assertEqual(list_primes_up_to(2), [2])
        self.assertEqual(list_primes_up_to(3), [2, 3])
        self.assertEqual(list_primes_up_to(10), [2, 3, 5, 7])

    def test_list_primes_up_to_medium_limit(self):
        self.assertEqual(list_primes_up_to(20), [2, 3, 5, 7, 11, 13, 17, 19])
        self.assertEqual(list_primes_up_to(0), [])

    def test_list_primes_up_to_negative_limit(self):
        self.assertEqual(list_primes_up_to(-5), [])

    def test_list_primes_up_to_type_error(self):
        with self.assertRaises(TypeError):
            list_primes_up_to(3.14)
        with self.assertRaises(TypeError):
            list_primes_up_to("abc")

if __name__ == '__main__':
    unittest.main()

   python -m unittest test_prime_checker.py
   ```
Ideally, all tests should pass, confirming the agent's successful completion of the task.

**Honest Downside**: While `crewAI` provides the `full_output` option, directly extracting generated code files from the console output can be cumbersome. For more solid file generation, agents often need to be equipped with specific tools (e.g., a `WriteFileTool`) that allow them to interact directly with the file system. In this basic example, we focused on the agent orchestration itself.

## Common Issues

Working with AI agents, especially in autonomous development, can present unique challenges:

* **API Key and Rate Limit Issues**:
* **Problem**: `AuthenticationError`, `RateLimitError`, or `APIConnectionError`.
* **Solution**: Double-check your `.env` file for correct key. Ensure your API key has billing enabled and sufficient quota. For rate limits, consider adding retry logic or using models with higher limits, or simply waiting and retrying.
* **Context Window Limits**:
* **Problem**: Agent gets confused, forgets earlier instructions, or generates incomplete code for complex tasks. This often manifests as truncated outputs or repeated attempts at solving the same problem.
* **Solution**: Break down complex tasks into smaller, more manageable sub-tasks. Provide concise, clear instructions. Sometimes, using a more capable (but often more expensive) LLM with a larger context window (e.g., `gpt-4o`, `gpt-4-turbo`) can help.
* **Hallucinations/Incorrect Logic**:
* **Problem**: Agent generates plausible-looking but incorrect code, tests, or research summaries. This is a fundamental challenge with LLMs.
* **Solution**: Implement solid review stages (like our `reviewer` agent). Always manually verify critical code. Provide very specific instructions and examples. Integrating agents with external tools (e.g., a Python interpreter, a search engine) can help ground their responses in reality.
* **Infinite Loops/Stuck Agents**:
* **Problem**: An agent might get stuck in a planning or re-planning loop, continuously trying to achieve a task without making progress, or generating similar outputs repeatedly.
* **Solution**: Review the agent's `backstory`, `goal`, and `task` descriptions. Sometimes, overly broad or contradictory instructions can cause this. Adding `max_rpm` (rounds per minute) or `max_iter` (maximum iterations) limits to tasks or the crew can prevent runaway execution.
* **Environment Setup Errors**:
* **Problem**: `ModuleNotFoundError`, `PermissionError`, or issues with virtual environments.
* **Solution**: Always activate your virtual environment. Double-check `pip install` commands. Ensure file permissions are correct if agents are trying to write files.
* **Overly Broad or Ambiguous Tasks**:
* **Problem**: Agents struggle with vague instructions, leading to irrelevant or incomplete outputs.
* **Solution**: Be as specific as possible in your `task` descriptions. Define clear `expected_output` formats. Think like you're writing a detailed specification for a human developer.

## Next Steps

You've successfully run your first autonomous agent crew! This is just the beginning. Here's what you can explore next:

* **More Complex Tasks and Projects**:
* Try building a simple web API with Flask/FastAPI, including database integration.
* Ask agents to refactor existing code, add new features to a small project, or even debug a known issue.
* Experiment with larger projects by breaking them down into multiple, interconnected crews or sequential tasks.
* **Custom Tools Integration**:
* `crewAI` (and other frameworks like `LangChain` and `AutoGen`) allow you to give agents custom tools. This is crucial for making agents truly autonomous.
* **File System Tools**: Allow agents to read, write, and modify files directly (e.g., `WriteFileTool`, `ReadFileTool`).
* **Git Tools**: Enable agents to clone repositories, commit changes, create branches, and open pull requests.
* **API Tools**: Provide agents with access to external APIs (e.g., a weather API, a database API, a project management API).
* **Human-in-the-Loop Tools**: Allow agents to ask for human input or approval at critical junctures.
* **Exploring Other Agent Frameworks**:
* **`AutoGen` (Microsoft)**: Focuses on multi-agent conversations, where agents can communicate and collaborate to solve tasks. Excellent for complex, interactive problem-solving.
* **`LangChain` Agents**: A more general-purpose framework with a vast array of integrations and agent types, suitable for highly customized solutions.
* **`LlamaIndex` Agents**: Primarily focused on data retrieval augmented generation (RAG), useful for agents that need to query custom knowledge bases.
* **Local LLMs**:
* Run agents with open-source models like Llama 3, Mixtral, or Gemma locally using tools like `Ollama` or `LM Studio`. This offers greater privacy, potentially lower costs, and can be faster for certain tasks, though local models might not yet match the reasoning capabilities of state-of-the-art cloud models.
* **Evaluation and Benchmarking**:
* How do you know if your agents are performing well? Explore methods for evaluating agent performance, such as defining success criteria, tracking task completion rates, and measuring code quality.
* **Integration with CI/CD Pipelines**:
* Imagine agents proposing code changes, creating pull requests, and initiating automated tests as part of your existing CI/CD workflow. This is where autonomous development truly integrates into the modern software development lifecycle.

The world of AI coding agents is rapidly evolving. By understanding the fundamentals and experimenting with these tools, you're positioning yourself at the forefront of a significant shift in how we build software. Happy coding!

## Recommended Reading

*Deepen your skills with these highly-rated books. Links go to Amazon — as an affiliate, we may earn a small commission at no extra cost to you.*

- [Co-Intelligence: Living and Working with AI](https://www.amazon.com/s?k=co+intelligence+ethan+mollick&tag=devtoolbox-20) by Ethan Mollick
- [The Pragmatic Programmer](https://www.amazon.com/s?k=pragmatic+programmer+hunt+thomas&tag=devtoolbox-20) by Hunt & Thomas