The Old Way vs The New Way

The World’s #2 Coder Works for You

In December 2025, AI models placed 2nd in the world’s top competitive programming competitions.

Better than 99.99% of human programmers

Solves complex algorithmic problems in seconds

Understands every language, framework, and pattern

Has perfect memory - never forgets a single detail

Available 24/7, infinitely patient, never gets tired

“Vibe Coding”

Coined by Andrej Karpathy (OpenAI co-founder, ex-Tesla AI lead) in February 2025. Named Collins Dictionary Word of the Year 2025.

In 2026, it has evolved into Agentic Engineering:

Write natural-language specs

AI generates code under structured human oversight

Multi-model orchestration with persistent project context

The developer specifies, reviews, and steers - AI implements

These Are Not Autocomplete

The 2000x Claim

Let’s do the math with real numbers:

A Real Example

Without AI: 2–3 weeks. With AI: 4 hours.

What Changed?

LLMs have perfect memory and infinite knowledge.

They were trained on virtually all public code ever written - and they memorized it

Context windows are now 1M+ tokens - they remember your entire conversation

They read your entire project before writing a single line

They understand your naming conventions, architecture, and style

They know every framework, library, and best practice ever published

This is not a search engine. This is a world-class engineer with perfect memory who has read every codebase on GitHub and never forgets a single detail.

Your Role Has Changed

Install the Basics

$ brew install git node
$ git --version
$ node --version

$ sudo apt install git nodejs npm
$ git --version
$ npm --version

PS> winget install Git.Git
PS> winget install OpenJS.NodeJS
PS> git --version

Use the Tool Well

Before adding memory systems, learn the basic loop: open the repo, give context, ask for one change, inspect the diff, and run it.

First Project Workflow

$ mkdir my-portfolio
$ cd my-portfolio
$ git init
$ opencode

> Here is my CV: [paste CV]. Build me a polished personal portfolio
  site like emrevarol.com. Include a hero, about section, experience
  timeline, skills, education, and contact. Make it responsive.

Your Agent Is Your IDE

The important shift is not which editor you open. It is who understands the repository and can act on it.

Terminal lovers: run agents directly in the repo and inspect diffs from Git

IDE people: use desktop apps/extensions, but keep the same small-commit workflow

Teams: standardize repo memory, commands, and verification gates

Everyone: context, plan, edit, run, inspect, commit

Your Stack Beyond Code

Building a product is not just code. You need infrastructure. Here’s what we use - all set up from the terminal:

Behavior-Driven, Not Code-Driven

The Iteration Cycle

This is your new workflow. Memorize it.

Step 1: Start Small

Begin with the simplest possible version.

> Build a complete English
learning platform with AI tutor,
assessments, writing/speaking/
listening modules, vocabulary,
grammar, leaderboards, friends,
18 languages, and auth.

> Create a Next.js app with a
landing page for an English
learning platform. Show 4
learning modules (Writing,
Speaking, Listening, Vocabulary)
as cards. Hardcoded for now.

Step 2: Add One Feature

Once the base works, add exactly one feature.

# Iteration 2: Add a database
> Replace the hardcoded data with a PostgreSQL database using Prisma.
  Create Lesson, Module, and Progress models. Seed sample lessons
  for each module.

# Iteration 3: Add user auth
> Add NextAuth with email/password. Users should be able to sign up
  and log in. Show their name in the navbar when logged in.

# Iteration 4: Add AI tutor
> Add a /tutor page with a conversation interface. Users type a
  message, Claude API responds with English corrections and tips.
  Track conversation history.

Step 3: Test the Behavior

After each feature, test the behavior, not the code.

Open the app in your browser

Click through the feature like a user would

Try edge cases: empty inputs, wrong data, double clicks

Check mobile view

You do NOT need to:

Read every line of generated code

Understand every helper function

Review the CSS class names

Step 4: Modify and Iterate

Something not right? Tell the AI what to change - in behavior terms.

# Not: "change the onClick handler to use a different state variable"
# Instead:
> When I finish a lesson, the progress bar doesn't update until I
  refresh the page. Fix this so the progress updates immediately.

# Not: "add a try-catch around the API call"
# Instead:
> When the AI tutor API call fails, the chat just freezes. Show a
  red error message that says "Connection lost, please try again"
  and re-enable the send button.

Step 5: Bake It → Move On

A feature is “baked” when:

It works as expected in all cases you can think of

It handles errors gracefully

It looks good on desktop and mobile

You’ve tried to break it and couldn’t

Once baked: commit, and move to the next feature.

> Commit all changes with message "Add AI tutor with conversation history"

Don’t Review Code. Review Behavior.

This is the hardest mindset shift for experienced engineers.

Trust the Machine

A hard truth from my experience:

It never forgets to handle edge cases

It follows conventions perfectly

It writes consistent patterns across files

It never gets lazy or takes shortcuts

It knows every best practice from every framework

This doesn’t mean it’s always right. It means your default should be trust, then verify - not distrust, then rewrite.

Your New Role: Architect + PM + QA

You are now three roles in one:

The Prompt Is Your Specification

A good prompt is a good spec. A bad prompt is a bad spec.

> Add a dashboard

> Add a dashboard page at /dashboard.
  Show the user's learning streak,
  completed lessons, vocabulary
  mastery %, and recent activity
  (last 10 sessions). Include a
  chart showing progress over time.

Incremental Over Monolithic

Project: emrevarol.com

Personal brand, lectures, writing, proof

emrevarol.com

Personal brand, lectures, writing, and proof for useful AI products.

Project: Engram

Shared memory for AI coding agents

engram.tools

Long-term memory for AI agents and team knowledge.

Project: evimibul.org

AI-powered real estate search

evimibul.org

AI-powered real estate search and decision support for Turkey.

Project: english.cash

AI English learning for the global workforce

english.cash

Practical, personal, accessible AI English learning.

The Pattern Across Projects

Different domains, same working model:

1. Start with a real human need

2. Describe the behavior clearly

3. Prototype quickly with AI

4. Test the product through behavior

5. Improve with logs, small commits, and memory

Parallel Agents with GenAI

Need to translate to 9 languages? Don’t do it one by one.

# Claude Code can spawn sub-agents that work in parallel
> Translate the lecture page to all 9 supported languages
  (TR, FR, DE, ES, AR, PT, RW, SW, AM). Use parallel agents
  for each language.

# Result: 9 agents work simultaneously
# 36 files translated in ~5 minutes instead of ~45 minutes

Context Is Everything

The AI is only as good as the context you give it.

AGENTS.md / CLAUDE.md - project-level instructions, tech stack, rules

Engram - shared long-term memory across agents and sessions

Memory files - persistent knowledge across conversations

Clear prompts - specific, behavior-focused descriptions

Existing code - the AI reads your codebase and follows your patterns

# Bad context: starting from scratch every time
> make a page

# Good context: AI knows your project inside and out
> Add a /friends page similar to /leaderboard. Show mutual friends
  at the top, then suggested friends based on similar learning paths.
  Use the existing FriendRequest model.

When AI Gets Stuck

It happens. Here’s what to do:

Simplify the prompt - break it into smaller pieces

Give examples - show what you want, not just describe it

Share error messages - paste the exact error, AI is great at debugging

Try a different approach - “instead of X, try Y”

Start fresh - sometimes a new conversation with clear context works better

Debugging with AI

AI is an incredible debugger.

# Just paste the error and describe the context
> I'm getting this error when I click the Buy button:
  "TypeError: Cannot read properties of undefined (reading 'price')"
  This happens only when the market has no trades yet.

# The AI will:
# 1. Find the relevant file
# 2. Identify the bug
# 3. Fix it
# 4. Explain what went wrong

Multi-File Changes

One of AI’s biggest advantages: it edits many files atomically.

> Add a "favorites" feature. Users can bookmark listings.
  Show a heart icon on each listing card, a /favorites page
  with saved listings, and a count badge in the navbar.

# AI will modify in one go:
# - schema.prisma (new Favorite model)
# - API route (CRUD for favorites)
# - ListingCard component (heart button)
# - Navbar (favorites count)
# - New /favorites page
# - Database migration

What NOT to Do with AI

Don’t paste AI-generated code into Stack Overflow answers (it’s not yours)

Don’t skip testing because “the AI wrote it”

Don’t use AI for security-critical code without expert review

Don’t stop learning fundamentals - you need to understand what you’re building

Don’t give up after one failed attempt - rephrase and try again

Don’t try to build everything in one giant prompt

Production Safety (1/2)

Real incidents from building these projects with AI.

1. Always Have Backups

git push --force destroyed a live site (Impact page, Press page, GenAI lecture — gone)

Recovery was only possible because Vercel kept old deployments and a second clone existed

Rule: Never force push. Never rebase shared branches. Always have a rollback strategy.

2. Guard Your API Keys

AI models can autonomously use API keys and rack up thousands of dollars without you realizing

Rule: Set spending limits. Use separate keys per project. Monitor usage daily.

Production Safety (2/2)

3. Log Everything & Generate Reports

You need daily activity reports and finance reports — know what your AI agents did and what they spent

Use services like Resend to email yourself automated daily summaries

Rule: If you can’t see what happened yesterday, you’re flying blind.

The Human’s Irreplaceable Role

AI cannot replace you in these areas:

Vision - What should we build? Why? (for now)

Empathy - What do users actually need? (for now)

Judgment - Is this the right approach? (for now)

Taste - Does this feel right? Is it good enough? (for now)

Key Takeaways

1. Manual coding is no longer the bottleneck; clear product judgment is.

2. Describe behavior, not implementation details.

3. Make one small change, run it, then continue.

4. Review outcomes with screenshots, tests, logs, and real local state.

5. Keep secrets on the server and costs observable.

6. Treat localization and mobile layout as product work, not a string replace.

7. Use reusable patterns for chatbots, provider rotation, and agent memory.

8. Add Engram when the project has decisions worth remembering.

9. Guard your API keys.

10. Always have rollback and backups.

Your Homework

Build something real this week.