How to start your AI Projects

I've been building a lot recently with Claude Code and have found a lot of advice on how to convert an existing code base for AI, but not much on a green field project. Admittedly I'm definitely not a full Vibe Coder, because I care deeply about the outcome and how we get there. Here are my tips on how to get a new project off the ground.

Begin with a Clean Project Structure Before writing prompts or model calls, establish a clear Python package structure. Separate orchestration, domain logic and model interaction. Avoid mixing scripts and application logic. A simple starting layout might be:

project/
  app/
    __init__.py
    services/
    models/
    prompts/
    utils/
  tests/
  config/
  infrastructure/
  pyproject.toml

Build for Observability

AI systems require careful logging. Capture inputs, outputs and metadata in structured logs.

import logging
 
logger = logging.getLogger(__name__)
 
logger.info(
    "model_response",
    extra={
        "prompt": prompt,
        "tokens_used": token_count,
    },
)

This enables debugging and performance analysis without manual inspection.

Use Dependency Management Properly

Adopt a modern Python dependency workflow such as: • uv • Poetry • pip-tools Lock dependencies. Use virtual environments. Avoid global installations. AI projects often rely on fast-moving libraries, so reproducibility matters. Keep Orchestration Separate from Business Logic Avoid turning Python scripts into orchestration layers. Use clear entry points.

def main():
    service = SummaryService(model_client)
    service.run()
 
if __name__ == "__main__":
    main()

This keeps your application composable and testable.

Design for Iteration

AI systems evolve through experimentation. Structure the code so prompts, evaluation logic and model selection can be changed without refactoring the core system. Avoid tightly coupling evaluation and inference.

Final Thoughts

A Python AI project benefits from the same engineering discipline as any other system. Clear package structure, explicit configuration, testable abstractions and proper logging provide the foundation for sustainable development. AI tooling accelerates coding, but thoughtful scaffolding ensures the system remains robust, maintainable and adaptable over time.