New AI Ways of Working: 10 Principles for Product Engineering Teams

AI isn't just changing what we build — it's fundamentally transforming how we work. Product engineering organizations across Dev, PM, Program, and QA must evolve their principles to fully leverage this shift. At Fynd, we are actively driving these changes so we can truly harness the power of AI across our entire Product Engineering organization.

Below are the proposed ways of working for our teams to truly accelerate every role within Product and Engineering, while significantly reducing the handoffs that typically occur across organizations.

1. Single Repo per Product

Consolidate all related microservices for each product into a single Git repository. The long-term goal is to lesser the repos, easy to setup and manage.

This doesn't mean collapsing into a monolith. You continue with a microservices architecture. The change is at the git/code repo level — creating a unified codebase per product to improve accessibility, simplify onboarding, ensure stack consistency, and make the codebase easier to navigate.

The real unlock: non-tech team members can now contribute meaningfully. Product Managers should be able to contribute at an SDE-1 level with AI assistance. Design teams should be able to directly support UI/UX improvements. Easy and medium development tasks become genuinely accessible to everyone.

2. Repo as the Central Knowledge Hub

Your repo should become the single source of truth for all knowledge and documentation. Create a /docs directory and store everything there — instead of spreading information across ticket systems, document tools, PDFs, and other scattered platforms.

Skills, documentation, rules, hooks, and runtime versions should be centralized. Even if content originates as an image, PDF, or diagram, convert it to Markdown to improve AI visibility and contextual understanding.

The repo effectively becomes a fully indexed knowledge base for AI-powered IDEs like Cursor or Claude Code. These tools automatically consume the contextual information and enable a unified operating surface for all stakeholders — QA engineers, program managers, and product managers can explore and question the code directly, minimizing information loss during translation.

3. Stop Coding APIs, Start Coding Agents

Instead of building traditional APIs, start building agents. Shift your mindset toward designing intelligent, autonomous systems that can reason, decide, and act.

Explore frameworks like LangGraph, OpenAI Agents, CrewAI, and similar tools. These ecosystems already provide the foundations you need — don't spend time reinventing basic infrastructure.

CRUD is no longer a differentiator. It's essentially a "hello world" prompt. With AI-powered IDEs, anyone who can write clear English can generate CRUD applications in under an hour.

4. Feature-Based Teams, Not Service-Based Teams

No more Frontend teams, Backend teams, or function-based groups. Operate as feature-first, outcome-driven teams.

Every team owns a feature end-to-end — from problem definition and design to development, integration, testing, release, and post-launch impact. No fragmented ownership, no layer-based handoffs, no "that's another team's responsibility."

When a feature comes in, a single team takes full accountability to ship it — completely and correctly. End-to-end ownership. Clear accountability. Real outcomes.

5. Go Beyond Role Boundaries

Boundaries between Devs, QAs, PMs, and Program are becoming invisible.

AI has dramatically lowered the barrier to execution. You no longer need deep specialization to contribute meaningfully across frontend, backend, testing, automation, or documentation. With AI IDEs and plain-English interfaces, anyone can build CRUD apps, generate UI, write scripts, or create tests.

PMs and Program Managers should become technically fluent and prototype with AI. Engineers should engage directly with customers and shape solutions, not just implement tickets. The future belongs to those who think in terms of end-to-end problem ownership rather than functional silos.

6. Code Is Cheap — Ownership, Innovation, and Speed Matter

Generating code is no longer a scarce skill. What's scarce is clarity of thought, strong judgment, deep problem understanding, and the ability to move fast with conviction.

The differentiator is not "Can you code?" but "Can you identify the right problem, design the right approach, and drive it to impact quickly?" As AI compresses execution time, the premium shifts to decision-making quality and initiative.

Either expand your role beyond defined boundaries, or become an ultra-expert in problems that go far beyond what AI can handle — deep performance engineering, advanced security analysis, large-scale architecture design, and complex domain challenges built on non-public knowledge.

7. QA Must Move Beyond Manual Work

Quality engineers need to upgrade to full quality-and-automation engineers.

It has never been easier to automate. What used to require extensive code now takes barely 15 minutes to create with AI assistance — and with the highest code quality possible. QA has the best edge right now: building has become easy, but verification is still unsolved. It needs people who can test through automation as well as manually.

QA engineers can start fixing small bugs themselves. If you're still doing only manual work, it reflects a lack of initiative to think beyond the task at hand.

8. Keep Architecture Simple Until You Have Scale

Do not introduce complex tech stacks before you have real scale. In the early stages, speed and clarity matter far more than architectural sophistication. Start with something simple, easy to comprehend, and with minimal moving parts.

Adding Kafka, Redis, or other heavy components for small extensions is often a waste of memory, engineering effort, and operational overhead. Complexity should be earned, not assumed.

Optimize fundamentals first. If your database indexes aren't fully optimized, adding a caching layer is just masking inefficiency. Build simple, scale when necessary, and introduce advanced components only when the problem genuinely demands them.

9. Don't Fall for the "AI Will Make Me Forget How to Code" Hoax

The argument that using AI will make us forget how to code is like saying we shouldn't use washing machines because we might forget how to wash clothes by hand. What truly matters is the outcome and value delivered — not the manual effort behind it.

We no longer write most systems in Assembly or even C, despite their efficiency. Higher-level tools let us move faster and build more complex systems. AI is simply the next step in that evolution — accelerating development and allowing us to focus on higher-order problem-solving.

At our core, we are problem solvers. Writing code is just one tool in our toolkit. It enables the solution, but it is not the solution itself.

10. Be Curious, Ask AI Everything

Don't be afraid to ask AI every single question, no matter how basic. There's no judgment — AI is endlessly patient and available 24/7.

Use AI as your personal teacher. Let it explain concepts step by step until you understand something end-to-end. The fastest way to fill knowledge gaps is to simply ask, instead of pretending you know something or spending hours searching.

Learning is a two-way street. As you ask AI questions, you also teach it your context — your codebase, your product, your constraints. The more you interact, the better it gets at helping you.

The people who will grow the fastest are not the ones who already know everything — they're the ones who are curious enough to keep asking until they truly get it.