It's 2025, and Vibe Coding has truly become a reality—I find this development genuinely exciting.

After successfully completing several projects using exclusively Vibe Coding, I now feel confident in my ability to produce consistent results at a steady pace. While AI can help solve many well-defined smaller problems, there are no simple answers to complex questions. It remains humanity's role to ask the right questions, systematically break down never-before-solved complex problems into manageable parts, and then delegate execution to either people or AI.

Minimize Context

Keeping the context window as small as possible is crucial, and ensuring that AI agents provide executable generated code is essential. Humans also struggle with tracking information, particularly in large, complicated projects. This is why people appreciate taking notes and documenting their thought processes.

A similar concept is "attention span." As experienced programmers, we train ourselves to maintain effective attention spans and remember necessary items. However, we all have limits. In programming's early days, before language servers existed, I would often get lost when renaming variables. I'd have to run the program only to discover I'd forgotten to change a variable name somewhere else. This experience trained me to maintain an effective attention span and remember considerable information. Still, I recognize my limitations and frequently take notes and add markers in code to help me remember.

When working with AI, minimizing the context window becomes even more critical. Tokens are expensive, and larger context windows increase costs significantly. And it could led to hallucination.

Single-Screen Code Review

All code should be visible on a single screen for easy review, as it's important not to fully trust AI output. AI hallucination remains a genuine concern, making verification of generated code essential. In most cases, I ask AI to generate more code than needed, allowing me to remove unwanted portions.

Code reviews also broaden the reviewer's perspective, helping them learn new patterns, better understand use cases, and improve their coding skills. I've learned tremendously from this process and continue to be amazed by the novel implementation paradigms that LLMs generate.

When requesting code generation from AI, I always ask for a README.md, a CLI interface for running the code, and the actual implementation. After each generation, I quickly review the README.md to understand the code's purpose. Then I test the code from the terminal using the CLI interface while examining the implementation code alongside. My wide screen comfortably fits all three editor columns side-by-side, making the review process exceptionally easy and efficient.

Product Experience and Focus

Solving customer problems requires substantial experience in understanding requirements and business outcomes. The focus should remain on addressing customer needs by breaking down complex issues into smaller, manageable components.

Identifying the right questions to ask is a skill that demands experience and practice. System boundaries often remain unclear, particularly when we're deeply immersed in a problem or working closely with clients. We must help clients articulate their true needs and then break these down into problems that computers can solve while meeting cost and time constraints.

Recognizing knowledge gaps is another skill that requires experience, as does determining the appropriate context to provide AI. This resembles the Tech Lead role in software teams—Tech Leads aren't always the best coders, but they typically possess the deepest understanding of both the system and business requirements. As a Tech Lead, you distribute work to team members, ensuring timely completion that meets requirements. In this case, however, the team members are AI agents.

Future Thoughts

I strongly believe programmers will become less essential in the future, with basic programmers and testers eventually disappearing. While programming roles may diminish, experienced product managers with solid technical understanding will be in higher demand.

Basic product management skills won't suffice—future product managers must understand technology thoroughly and break down complex problems effectively. Typically, this type of product manager emerges from a programming background.

Recently, the term "Forward Deployed Engineer" has gained popularity, and I find it accurately describes future product management roles. The boundary between product managers and engineers will continue to blur. While engineers aren't always the best communicators, they genuinely understand technology and its limitations. Therefore, engineers should enhance their communication skills and develop expertise in expectation management.

I think the people who remain are those who can adapt to the changes, not the strongest one. Dinosaurs were very strong, but they could not adapt to the changing environment, so they are all gone. This need for adaptation is evident in the programming landscape, where basic programmers and testers are expected to become less essential in the future as Vibe Coding and AI become a reality. Survival, therefore, depends on adapting one's role to focus on strategic skills: recognizing knowledge gaps, asking the right questions, and breaking down complex, never-before-solved problems into manageable components that AI can then execute