Agentic AI Engineering in Practice: How AI Engineers and Forward-Deployed Engineers Use Claude Code, Codex, and Gemini

Introduction to Agent-Based Programming

In March 2025, a small non-profit organization decided to reevaluate their approach to software development using modern artificial intelligence (AI) technologies. In this article, we will explore a practical approach to implementing agent-based programming (agentic AI engineering) using three tools: Claude Code, Codex, and Gemini. We will break down the development process into key stages: pla

ing, design, development, testing, deployment, and support.

Stages of Software Development Using Agent-Based Programming

Pla

ing

The first step in any development is pla

ing. It's crucial to define the tasks you want to solve with AI and select appropriate tools. In this context, we will use Claude Code for idea generation and initial pla

ing.

# Example of using Claude Code for generating ideas
def generate_ideas(prompt):
    response = claude_code.generate(prompt)
    return response

ideas = generate_ideas("What features can be added to our project?")
print(ideas)

Design

After pla

ing, we move on to designing. Here, it's important to define the system architecture and choose suitable tools for implementation. Codex can assist in this process by providing ready-made code templates and recommendations for system structure.

# Example of using Codex to create a basic project structure
def create_project_structure():
    project_structure = codex.create_structure("Project Name")
    return project_structure

structure = create_project_structure()
print(structure)

Development

Now we can start developing. Here, we use Gemini for writing and testing code. This tool allows for quick creation and modification of code, as well as automatic error checking.

# Example of using Gemini for writing and testing code
def write_and_test_code(code_snippet):
    result = gemini.write_and_test(code_snippet)
    return result

code_snippet = "def add_numbers(a, b): return a + b"
result = write_and_test_code(code_snippet)
print(result)

Testing

After writing the code, it needs to be tested. It's essential to use automated tests to ensure the quality and reliability of the code. Gemini also provides tools for automatic testing.

# Example of using Gemini for automatic testing of code
def run_tests(test_cases):
    results = gemini.run_tests(test_cases)
    return results

test_cases = [{"input": 1, "expected_output": 3}, {"input": 2, "expected_output": 4}]
results = run_tests(test_cases)
print(results)

Deployment

After successful testing, the code can be deployed to a production environment. This may include deploying on servers or cloud platforms. Security and scalability considerations are important here.

Support

After deployment, it's necessary to provide support for the system. This includes monitoring performance, updating the code, and resolving any issues that arise. Automation tools for support operations can also be beneficial.

Practical Tips

1. Regular Training: Stay current by regularly studying new technologies and development methods.
2. Cross-functional Team: Collaboration between AI engineers and forward-deployed engineers helps achieve a better understanding of requirements and tasks.
3. Automation: Using automated tools for testing and deployment can significantly enhance development efficiency.
4. Security: When developing with AI, it's crucial to consider security and data protection issues.

Conclusion

Using agent-based programming with Claude Code, Codex, and Gemini opens up new possibilities for software development. This approach enables more efficient and high-quality problem-solving using modern AI technologies.