About the Speaker and Podcast

Oles Petriv is a prominent figure in the Ukrainian AI scene, known for his work at Reface and his deep, long-standing involvement in artificial intelligence, which predates the recent hype. With a background that combines hands-on engineering (his GitHub handle is php3ik) and high-level conceptual thinking, he offers a uniquely practical perspective on AI development.

This summary is based on his appearance on the “УТ-2” podcast, hosted by Yurii Fedorenko.

Summary of AI Software Development Practices & Tools

Oles Petriv outlines a sophisticated and pragmatic approach to software development in the age of AI, emphasizing that the developer’s role shifts from a pure coder to an architect and strategist, with the AI serving as a powerful, high-speed translator.

1. The Core Philosophy: The Developer as Architect, AI as Translator

The most critical mistake developers make is treating AI coding assistants as autonomous engineers. Petriv’s core principle is that the human must do the high-level thinking, planning, and structuring. The AI’s role is to translate that well-defined plan into code.

  • The Anti-Pattern: Simply giving a vague prompt like “Build me an app that does X” to a tool like Cursor will lead to poor, unmaintainable code. The AI lacks the necessary context about constraints, goals, and the broader system architecture.
  • The Effective Approach: The developer invests the majority of their time in creating an extremely detailed plan. The AI then executes that plan, which is a task it excels at.

2. A Step-by-Step Workflow for Prototyping and Development

Petriv shared his personal workflow for tackling a new project, such as integrating two different open-source AI models.

  1. Deep Research Phase:

    • Start by clearly defining the problem and the desired outcome in natural language.
    • Use the “deep research” capabilities of multiple LLMs (ChatGPT, Grock, Gemini) to gather all relevant information. This includes academic papers, GitHub repositories, documentation, and even discussions by the original authors.

  2. Synthesis and Planning Phase:

    • Feed all the collected research into a single, powerful model (e.g., GPT-4o or Claude 3 Opus).
    • Instruct the AI to act as a system architect and create an “ultra-detailed technical specification” (ТЗ). Crucially, this specification should be written for an AI agent, not a human. This means it must be explicit, unambiguous, and cover every detail.
    • The specification should include:
      • A clear project plan and structure.
      • Identification of potential conflicts (e.g., conflicting library versions like PyTorch or CUDA between different repos).
      • A proposed class structure and architecture.
      • Test cases, which should be defined upfront to guide the development process.

  3. Iterative Refinement:

    • Review the generated plan with the AI. Edit and refine it in a conversational loop.
    • Petriv emphasizes “training” the agent on your feedback: “Remember how I edited this, and add it to your long-term memory so I have to edit less next time.”

  4. Execution Phase:

    • Once the detailed specification is finalized, provide it to an AI coding assistant (Cursor, Windsurf) to generate the code. Because the plan is so robust, the AI is far less likely to make logical errors or go down a wrong path.

3. Key AI Development Tools and Frameworks

  • Foundational Frameworks:

    • PyTorch: The de facto industry standard for AI research and development, akin to JavaScript in the frontend world. Most new papers release their code in PyTorch.
    • JAX / Flax: Specialized frameworks from Google that are extremely efficient for certain types of tasks, particularly those involving stateful, dynamic systems like Neural Cellular Automata. Petriv notes that for niche problems, a specialized framework can be orders of magnitude faster than a general-purpose one like PyTorch.

  • AI Coding Assistants:

    • Cursor and Windsurf: He uses these tools for AI-assisted coding.
    • Google’s Firebase Studio: An excellent “agentic” tool for rapidly prototyping and deploying web apps or demos by describing what you want in text.

  • Ecosystem Hubs:

    • Hugging Face: The “GitHub for AI models.” It’s the central repository for model weights, datasets, and demos.
    • GitHub: Remains the standard for hosting the source code of the projects themselves.

4. Choosing APIs for Production (Quality vs. Cost)

When building products like Reface’s BytePal (an AI nutrition coach) or Honestly (an AI journal), the choice of which AI API to use (OpenAI, Google, Anthropic, ElevenLabs) is a critical business decision, not just a technical one.

  • Unit Economics are Key: At scale, a difference of a few cents per million tokens can translate into massive costs. The decision is driven by a trade-off.
  • “Good Enough” is the Goal: You don’t always need the absolute best, most expensive model. The goal is to find a model that is good enough for a specific sub-task (e.g., text recognition vs. complex reasoning) at a cost that makes the product’s unit economics viable.
  • The Process: The team evaluates whether to use a third-party API, build an in-house solution, or use a cheaper but sufficient alternative based on the specific feature’s requirements and its impact on the overall cost per user.