DEV Community: Md Mijanur Molla

Excited to launch my latest full-stack project: NeighborHelp! 🤝✨

Md Mijanur Molla — Wed, 29 Jul 2026 06:20:53 +0000

Have you ever been in a situation where you needed immediate help from someone nearby?

Maybe you needed a blood donor, a local electrician, emergency transportation, pet care, or just someone in your neighborhood who could help quickly.

Finding the right person at the right time isn't always easy.

That's exactly why I built NeighborHelp — a modern community platform that helps people connect with nearby neighbors and provide or receive help in real time.

🌐 Live Demo:
https://neighborhelp99.vercel.app

💡 What Makes NeighborHelp Special?

📍 Smart Location-Based Help

NeighborHelp uses real-time location to show nearby help requests with distance filters like:

Within 5 km
Within 10 km
Within 25 km
Anywhere

This makes finding nearby help simple and fast.

💬 Real-Time Chat

Users can instantly communicate using a built-in chat system powered by Socket.io.

Features include:

Online status
Live typing indicators
Instant messaging

Everything updates in real time without refreshing the page.

🔔 Instant Notifications

Urgent requests shouldn't wait.

NeighborHelp instantly sends:

Web Push Notifications
Automated Email Alerts

so people can respond as quickly as possible.

🏆 Community Reputation System

Helping others deserves recognition.

The platform includes:

10-level badge system
Reputation points
Community success stories

to encourage active participation and build trust.

🤖 NeighborBot AI Assistant

An integrated AI assistant helps users by:

Answering common questions
Guiding new users
Suggesting helpful actions
Making the platform easier to use

🛡️ Secure Authentication

Security was one of my top priorities while building this project.

Features include:

JWT Authentication
Express Rate Limiting
OTP-based Password Recovery
Protected APIs

🛠️ Tech Stack

Frontend

Next.js 16
React
Tailwind CSS
Vanilla CSS

Backend

Node.js
Express.js
Socket.io
Web Push API

Database & Deployment

Supabase PostgreSQL
Vercel

💻 What I Learned

Building NeighborHelp from scratch helped me gain hands-on experience with:

Full-Stack Development
Real-Time Communication
AI Integration
Authentication & Security
Geolocation Services
Push Notifications
Database Design
Modern UI/UX

It was an exciting journey that pushed me to think beyond just writing code and focus on solving a real-world community problem.

❤️ I'd Love Your Feedback

If you have a few minutes, please check out the project and let me know what you think.

🌐 Live Demo:
https://neighborhelp99.vercel.app

Your feedback and suggestions will help me improve it even further.

Thank you for reading! 🚀

FullStackDevelopment #Nextjs #React #NodeJS #ExpressJS #SocketIO #Supabase #SoftwareEngineering #WebDevelopment #BuildInPublic #OpenSource #TechCommunity #SoftwareDeveloper

Why AI Can't Replace Software Architects (Yet)

Md Mijanur Molla — Mon, 27 Jul 2026 07:31:18 +0000

AI can generate code in seconds.

It can write APIs.

Build React components.

Fix bugs.

Even create an entire application from a single prompt.

So a question naturally comes up:

👉 If AI can write code, why do companies still need Software Architects?

The answer is simple.

Because writing code and designing software are two completely different skills.

Let's see why.

💡 AI Can Generate Code...

Ask AI to build:

A login API
A dashboard
A CRUD application
A payment integration

It will probably do a pretty good job.

That's because these are implementation tasks.

AI has seen millions of similar examples during training.

🏗️ But Architecture Starts Before Coding

Before writing even a single line of code, someone has to answer questions like:

Should we use a monolith or microservices?
SQL or NoSQL?
REST or GraphQL?
Should we cache this data?
How do we handle 10 million users?
What happens if one service fails?

These decisions shape the entire system.

And they don't have one correct answer.

⚖️ Architecture Is About Trade-offs

Every architectural decision comes with compromises.

For example:

Choosing microservices gives better scalability...

But also adds:

Network latency
Deployment complexity
Service communication
Monitoring challenges

Choosing a monolith makes development simpler...

But scaling large teams can become harder.

There's no universal "best" choice.

It depends on the business, the team, and the product.

🤖 AI Doesn't Know Your Business

AI can read code.

But it doesn't automatically know:

Your business goals
Budget constraints
Team experience
Customer expectations
Future roadmap

Without that context, it can only make educated guesses.

Architecture requires understanding the bigger picture.

🚨 The Cost of a Wrong Architecture

A bug can usually be fixed in hours.

A poor architectural decision can affect a product for years.

It can lead to:

Performance issues
Higher cloud costs
Difficult deployments
Slow development
Expensive rewrites

That's why architecture deserves careful thought.

👥 Great Architects Don't Just Design Systems

They also:

Talk to stakeholders
Understand business requirements
Balance technical and business needs
Plan for future growth
Help teams make consistent decisions

Much of their work happens outside the code editor.

🤝 AI Is a Great Assistant

AI can absolutely help architects by:

Comparing technologies
Reviewing designs
Generating diagrams
Explaining patterns
Suggesting alternatives

But the final decision still needs human judgment.

🎯 The Future Isn't AI vs Architects

It's AI + Architects.

Architects who know how to use AI will:

Explore ideas faster
Prototype quicker
Validate designs
Save time on repetitive work

AI becomes a powerful tool, not a replacement.

💡 Final Thought

AI is getting better at writing code every day.

But architecture isn't just about code.

It's about making decisions that balance technology, business, people, cost, scalability, and the future.

And that's something no model can fully understand without human experience and context.

At least... not yet.

💬 What do you think? Will AI ever replace Software Architects, or will it simply make them more productive?

AI #SoftwareArchitecture #SoftwareEngineering #ArtificialIntelligence #SystemDesign #Developers #Programming #Tech #LLM #Architecture

The Hidden Cost of AI Vibe Coding

Md Mijanur Molla — Tue, 21 Jul 2026 11:37:24 +0000

AI has completely changed how we build software.

Need a login page?

AI can generate it.

Need a REST API?

Done.

Need an entire SaaS boilerplate?

Just ask.

It feels like software development has become incredibly fast.

But there's a hidden cost that many developers don't notice...

👉 AI Vibe Coding.

Let's talk about it.

💡 What is Vibe Coding?

Vibe Coding is when developers rely heavily on AI to generate code without fully understanding what it does.

The workflow usually looks like this:

Ask AI to write code
Copy it
Paste it
Run it
If it works... move on.

No deep understanding.

No questioning.

Just trusting the output.

🚀 Why Everyone Loves It

To be fair, AI is amazing.

It helps developers:

Build prototypes faster
Learn new frameworks
Reduce repetitive work
Fix simple bugs
Generate boilerplate code

For many tasks, it's a huge productivity boost.

The problem isn't AI.

The problem is using it without understanding the code it generates.

⚠️ The Hidden Costs

1. You Stop Reading Your Own Code

If AI writes most of your code, it's easy to skip reading it carefully.

Until something breaks.

Then you realize...

You don't actually know how it works.

2. Debugging Becomes Harder

When a bug appears, AI isn't sitting beside you.

You are.

If you don't understand the implementation, fixing production issues becomes much more difficult.

3. Security Risks

AI can generate working code.

But "working" doesn't always mean "secure."

Small mistakes like:

Missing input validation
Weak authentication
SQL injection risks
Exposed secrets

can easily slip into production if you don't review the output.

4. Technical Debt Grows Faster

AI can generate features in minutes.

But if every feature follows a different pattern, your codebase slowly becomes inconsistent.

Months later, maintaining it becomes a challenge.

5. Learning Slows Down

If AI solves every problem instantly...

You may stop asking why.

And that's where real learning happens.

🧠 AI Should Be Your Pair Programmer

The best developers don't treat AI like an autopilot.

They treat it like a teammate.

They ask:

Why did you choose this approach?
Is there a better alternative?
What are the trade-offs?
Can you explain this logic?

That turns AI into a learning tool instead of just a code generator.

🎯 The Real Skill

In the AI era, writing code is becoming easier.

Understanding code is becoming more valuable.

The developers who stand out won't be the ones who copy the fastest.

They'll be the ones who can:

Review AI-generated code
Spot hidden issues
Make better architectural decisions
Know when the AI is wrong

💡 Final Thought

AI Vibe Coding isn't bad.

Blind AI Vibe Coding is.

Use AI to speed up your workflow.

But don't let it replace your curiosity.

Because one day, that AI-generated code will fail in production...

And the only person who can fix it will be you.

💬 Be honest... have you ever copied AI-generated code, watched it work, and thought, "I'll understand it later"? 😅

AI #VibeCoding #SoftwareEngineering #Programming #Developers #LLM #Coding #ArtificialIntelligence #Tech #DeveloperLife

The Hidden Engineering Behind Git Merge Conflicts

Md Mijanur Molla — Mon, 13 Jul 2026 12:23:30 +0000

If you've worked with Git for even a few weeks, you've probably seen this message:

CONFLICT (content): Merge conflict
Automatic merge failed.

Your heart sinks.

You stare at the screen and think:

👉 "What did I do wrong?"

The truth is...

Most merge conflicts aren't caused by bad developers.

They're simply a side effect of multiple people working on the same codebase.

Let's see what's actually happening behind the scenes.

💡 Git Doesn't Understand Your Code

Here's something many developers don't realize.

Git doesn't understand:

JavaScript
Java
Python
React
Node.js

Git simply sees...

👉 Text files.

It doesn't know what a function is or what a variable means.

It only knows:

"This line changed."

👨‍💻 A Simple Example

Imagine your login.js file contains:

function login() {
   return true;
}

Now two developers start working.

Developer A

Changes it to:

return false;

Meanwhile...

Developer B

Changes it to:

return validateUser();

Both changes happen on different branches.

🤔 Now Git Gets Confused

When the branches are merged...

Git asks itself:

"I have two different changes for the same line."

Which one should I keep?

Developer A's?

Or Developer B's?

Git has no idea.

So instead of guessing...

It stops.

And asks you to decide.

That's a merge conflict.

🚀 Why Git Doesn't Auto-Fix Everything

People often ask:

"Why can't Git just combine both changes?"

Because sometimes there isn't a correct answer.

Imagine:

One developer deletes a function.

Another developer adds new logic inside that same function.

Should Git:

Keep the deletion?
Keep the new logic?
Combine both?

Only the developer understands the intent.

Git doesn't.

⚙️ What Those Weird Markers Mean

When a conflict happens, you'll see something like:

<<<<<<< HEAD
Developer A's code
=======
Developer B's code
>>>>>>> feature-branch

Git is simply saying:

"Here are both versions.
You choose the correct one."

After editing the file and removing these markers, the conflict is resolved.

🤝 Why Merge Conflicts Increase in Large Teams

In small projects...

Conflicts are rare.

In large projects:

Multiple developers
Multiple features
Long-lived branches
Frequent releases

The chances of two people modifying the same file become much higher.

That's why enterprise teams often merge changes frequently instead of waiting for weeks.

💡 How Good Teams Reduce Merge Conflicts

Experienced teams don't eliminate conflicts completely.

Instead, they reduce them by:

Creating smaller pull requests
Merging branches frequently
Keeping branches short-lived
Improving communication
Breaking large features into smaller tasks

The goal isn't "no conflicts."

The goal is "easy conflicts."

🎯 The Bigger Lesson

A merge conflict isn't Git being broken.

It's Git protecting your work.

Instead of making the wrong decision...

Git lets the developer make the final call.

That's actually a safety feature.

🚀 Final Thought

The next time Git says:

"Automatic merge failed."

Don't panic.

It's not telling you that your project is broken.

It's simply saying:

👉 "Two smart developers made different changes. I need your help deciding which one is correct."

And that's the hidden engineering behind one of the most common messages every developer eventually learns to respect.

💬 What's the longest merge conflict you've ever had to resolve? 😄

Git #GitHub #SoftwareEngineering #Developers #Programming #VersionControl #Coding #WebDevelopment #DeveloperLife

Context Engineering: The Skill Replacing Prompt Engineering

Md Mijanur Molla — Mon, 06 Jul 2026 07:48:18 +0000

A couple of years ago, everyone was talking about Prompt Engineering.

People experimented with prompts like:

"Act as a senior software engineer."
"Think step by step."
"Explain like I'm five."

And it worked.

A better prompt often produced a better answer.

But AI is evolving.

Today, there's another skill that's becoming even more important:

👉 Context Engineering.

Let's understand why.

💡 What is Prompt Engineering?

Prompt Engineering is about asking better questions.

For example, instead of saying:

"Write code."

You might say:

"Write a scalable REST API in Node.js using TypeScript with proper error handling."

The better your prompt, the better the response.

Simple.

🚀 What is Context Engineering?

Context Engineering is about giving AI the right information, not just the right instructions.

Think about it.

If you ask an AI:

"Fix this bug."

It doesn't know:

Your project structure
Business requirements
Database schema
API contracts
Coding standards

Now imagine providing that context.

Suddenly, the AI can make much better decisions.

That's Context Engineering.

🤖 A Simple Example

Imagine two developers ask the same question.

Developer A

"Build a login API."

The AI makes assumptions.

Developer B

Provides:

Existing project structure
Authentication flow
Database schema
User roles
Tech stack
Coding guidelines

Then asks:

"Build a login API."

The second answer will almost always be better.

Not because the prompt changed.

Because the context changed.

🧩 Why Context Matters More

Large software projects aren't just code.

They're made up of:

Architecture
Business rules
Team conventions
Existing services
Dependencies

Without that information, even the smartest AI has to guess.

And guessing leads to mistakes.

📚 Where Does Context Come From?

Good AI systems gather context from many places, such as:

Code repositories
Documentation
Databases
APIs
Knowledge bases
Previous conversations

The goal is simple:

Give the AI enough information to make informed decisions.

⚡ Why This Matters for Developers

As AI becomes better at generating code, the real challenge isn't writing prompts.

It's providing the right context.

Developers who understand:

What information the AI needs
How to organize project knowledge
How to connect AI with tools and documentation

will get much better results.

🎯 Prompt vs Context

Think of it like this:

Prompt Engineering answers:

"What should I ask?"

Context Engineering answers:

"What should the AI know before it answers?"

Both are important.

But without context, even a perfect prompt has limits.

💡 Final Thought

The future of AI isn't just about writing smarter prompts.

It's about building systems that give AI the right context at the right time.

That's why many AI engineers are shifting their focus from Prompt Engineering to Context Engineering.

Because the best answers don't come from better questions alone.

They come from better understanding.

And in the AI era, context may become your biggest advantage.

💬 What do you think?

Is Prompt Engineering still enough, or do you think Context Engineering is becoming the more valuable skill?

Let's discuss below 👇

AI #ContextEngineering #PromptEngineering #LLM #AIAgents #SoftwareEngineering #Developers #Programming

I Found a Surprisingly Fun Way to Practice Frontend Development

Md Mijanur Molla — Fri, 03 Jul 2026 07:16:31 +0000

I recently started exploring VibeCode Arena: FIFA 2026 Showdown, and it's much more interesting than I expected.

Instead of solving traditional coding problems, you're challenged to build football-themed applications like:

⚽ Penalty Shootout Games
🏆 World Cup Predictors
📊 GOAT Ranking Dashboards
🎮 Fun FIFA Mini Games
🤖 Creative AI-powered football apps

What I like most is that it encourages creativity. You're not just writing code, you're designing interactive experiences with HTML, CSS, and JavaScript while competing with other developers.

If you're looking for a fun coding challenge or want to build something different from the usual CRUD apps, I'd definitely recommend giving it a try.

👉 Start here:

https://vibecodearena.ai/?page=1&pageSize=10&sortBy=responses&sortOrder=desc&utm_source=external&utm_medium=vc3&utm_campaign=fifa2026

I'm already trying a few ideas. Let's see who builds the most creative football app! ⚽🚀

Have you tried it yet?

🔌 MCP Explained: The AI Standard Every Developer Should Know

Md Mijanur Molla — Sat, 27 Jun 2026 10:27:15 +0000

Over the last few years, AI has become incredibly good at writing code.

But there was one big problem.

AI could answer questions...

Yet it couldn't easily interact with the tools developers use every day.

Think about it.

What if you ask an AI assistant:

"Show me all open GitHub issues."

Or:

"Read my PostgreSQL database."

Or:

"Deploy my application."

The AI needs a secure and standardized way to communicate with those tools.

That's exactly why MCP (Model Context Protocol) was introduced.

Let's understand it in simple terms.

💡 What is MCP?

MCP (Model Context Protocol) is an open standard that allows AI models to connect with external tools, applications, databases, APIs, and services in a consistent way.

Instead of every AI tool creating its own custom integration...

MCP provides one common language.

Think of it as:

USB-C for AI applications.

Just like USB-C lets different devices connect using one standard...

MCP lets AI connect to different software using one protocol.

🤔 Why Was MCP Needed?

Before MCP...

Every integration was different.

If an AI wanted to work with:

GitHub
Slack
PostgreSQL
Google Drive
Figma

Developers often had to build custom integrations for each one.

That meant:

More development time
More maintenance
More compatibility problems

There was no common standard.

🚀 How MCP Changes Everything

With MCP:

Applications expose their capabilities through an MCP server.

An AI assistant can discover those capabilities automatically.

Instead of hardcoding every integration...

The AI simply asks:

"What tools are available?"

The server responds with the available tools and how to use them.

Simple.

Consistent.

Scalable.

🏗️ A Simple Architecture

The communication flow usually looks like this:

AI Assistant
      │
      ▼
MCP Client
      │
      ▼
MCP Server
      │
      ▼
GitHub • Database • APIs • Files • Cloud Services

The AI doesn't need to know how every service works internally.

It communicates through MCP.

💻 A Real Example

Imagine you ask:

"Create a GitHub issue for the login bug and assign it to me."

Without MCP:

Someone has to manually copy the information.

With MCP:

The AI can:

Understand the request
Connect to GitHub
Create the issue
Assign it
Return the issue link

All in one workflow.

🌍 Where Can MCP Be Used?

MCP can connect AI with:

Source code repositories
Databases
Cloud platforms
Documentation
Project management tools
Internal company systems
File systems
Custom APIs

This makes AI much more useful than a simple chatbot.

🤖 Why This Matters for AI Agents

An AI model can generate text.

An AI agent needs to perform actions.

To do that safely and consistently, it needs access to tools.

That's where MCP becomes important.

It provides a structured way for AI agents to discover and use external capabilities.

⚡ Why Developers Should Care

If you're building:

AI copilots
Coding assistants
Internal company AI tools
Customer support agents
Automation platforms

Understanding MCP will help you build systems that are easier to extend and maintain.

Instead of creating dozens of custom integrations...

You can build around a common protocol.

🔥 Is MCP Replacing APIs?

No.

APIs are still the foundation.

MCP doesn't replace APIs.

Instead, it gives AI applications a standardized way to discover and use those APIs and other tools.

Think of it like this:

APIs expose functionality.
MCP helps AI understand and use that functionality consistently.

🎯 Why MCP Could Become a Big Deal

As more companies build AI-powered products, they'll need a reliable way to connect AI with existing software.

Without a standard, every integration becomes another custom project.

With a standard, developers can build once and reuse across many AI applications.

That's why many people see MCP as an important building block for the next generation of AI software.

💡 Final Thought

The future of AI isn't just about bigger models.

It's about helping those models work with the real world.

That's exactly what MCP is designed to do.

It gives AI a common way to interact with tools, services, and data.

And as AI agents become more common, understanding MCP may become as valuable as understanding REST APIs was for modern web development.

💬 Have you started experimenting with MCP yet?

Or are you still building AI integrations using custom APIs?

I'd love to hear your thoughts.

AI #MCP #AIAgents #LLM #ArtificialIntelligence #SoftwareEngineering #Developers #Automation #Programming #Tech

The More AI Writes Code, The More Architecture Matters

Md Mijanur Molla — Sun, 21 Jun 2026 12:05:27 +0000

A few years ago, one of the biggest challenges in software development was writing code quickly.

Today?

AI can generate:

Functions
APIs
Unit tests
Database queries
Entire applications

Sometimes in seconds.

At first glance, this sounds like amazing news.

And it is.

But it also creates an interesting shift.

👉 As AI makes coding easier, architecture becomes more important.

Let's explore why.

💡 The Old Bottleneck: Writing Code

Traditionally, development teams spent a lot of time on implementation.

Developers had to:

Write boilerplate
Build APIs
Create CRUD operations
Implement repetitive logic

This took time.

A lot of time.

Today, AI can generate much of that work.

What once took hours may now take minutes.

⚙️ AI Is Accelerating Implementation

Modern AI tools can:

Generate components
Create endpoints
Suggest database schemas
Write tests
Refactor code

The barrier to creating software is lower than ever.

But here's the catch.

Generating code is not the same as designing systems.

🧠 Architecture Answers Different Questions

AI is great at:

👉 "How should I build this?"

Architecture focuses on:

👉 "Should I build it this way?"

Those are completely different questions.

Architecture deals with:

Scalability
Reliability
Maintainability
Security
Future growth

And those decisions shape everything that comes later.

🚀 More Code Is Not Always Better

Here's an interesting paradox.

As AI makes it easier to generate code...

Teams may end up creating more complexity.

Why?

Because producing code becomes cheap.

And when something becomes cheap, people tend to create more of it.

More services.

More features.

More integrations.

More dependencies.

Without strong architecture, that complexity grows quickly.

💀 AI Can Build Fast. It Can Also Create Technical Debt Fast.

Imagine asking AI to generate:

Five microservices
Multiple APIs
Event-driven workflows
Background jobs

It can do it.

But if the overall design is weak:

👉 The system becomes difficult to maintain.

The problem isn't the code.

The problem is how everything connects.

🔄 Architecture Is About Relationships

Large systems are not collections of files.

They are collections of relationships.

Questions like:

Which service owns this data?
Where should business logic live?
How do systems communicate?
What happens when one service fails?

These decisions matter more than individual functions.

And AI doesn't automatically solve them.

📚 The More AI Generates, The More Context Matters

Good architecture depends on context.

Things like:

Business goals
Team size
Product roadmap
User behavior
Infrastructure constraints

These factors are often invisible in the code itself.

Two teams can use the same AI.

Generate similar code.

And end up with completely different outcomes.

Because context drives architecture.

🔥 Why Senior Skills Become More Valuable

Many people assume AI reduces the need for experienced engineers.

In reality, it may do the opposite.

As implementation gets easier:

The value shifts toward:

System design
Tradeoff analysis
Technical leadership
Architectural thinking

The challenge becomes:

Not writing code.

But deciding what code should exist.

⚡ A Real-World Example

Suppose AI builds:

Authentication
User management
Payment processing
Notification systems

All quickly.

Great.

But now someone must decide:

Should these be separate services?
How will they scale?
How will failures be handled?
Where will data live?

Those decisions define the system's future.

Not the generated code.

🎯 The New Competitive Advantage

In the AI era:

Writing code is becoming easier.

Understanding systems is becoming harder.

The developers who stand out won't necessarily be the fastest coders.

They'll be the people who can:

Design systems
Manage complexity
Make good technical decisions
Think long-term

That's architecture.

💡 Final Thought

AI is changing software development.

But it isn't removing complexity.

It's moving the bottleneck.

From:

❌ Writing code

To:

✅ Designing systems

The more AI writes code...

The more architecture matters.

Because in the end, software isn't judged by how quickly it was generated.

It's judged by how well it survives growth, change, and real-world usage.

And that's where architecture wins.

AI #SoftwareArchitecture #SoftwareEngineering #SystemDesign #LLM #Developers #Programming #TechLeadership #FutureOfWork #Coding

GrowQR AI Global Campus Program

Md Mijanur Molla — Sun, 14 Jun 2026 16:29:58 +0000

Haven't you heard yet?

The GrowQR AI Global Campus Program has been featured in Business Standard.
GrowQR is empowering students across India with opportunities to explore AI, leadership, innovation, career readiness, and community building.

As a Campus Ambassador, I'm excited to be part of a movement that's helping shape the next generation of AI-ready talent.

This is more than just a Campus Ambassador program—it's an opportunity to learn, lead, network, build meaningful connections, and create real impact on your campus while being part of a rapidly growing AI community.
Read the full article: https://bit.ly/4e3kog7

Want to become a GrowQR Campus Ambassador too?

Register here: https://www.growqr.ai/ambassadors/apply?utm_source=campusambassadors&utm_medium=md_mijanur_molla&utm_campaign=gaigcp

Let's build AI-ready talent, campus by campus.

The New Skill AI Can't Learn From Your Codebase

Md Mijanur Molla — Thu, 11 Jun 2026 08:06:14 +0000

AI can do some pretty impressive things today.

It can:

Generate code
Explain functions
Write tests
Refactor components
Create documentation

Sometimes it feels like AI knows your codebase better than you do.

And honestly?

For certain tasks, it probably does.

But there is one skill that AI still struggles to learn from your codebase.

And as AI becomes more powerful, this skill is becoming more valuable.

💡 The Great Misunderstanding

Many developers think:

👉 The future belongs to whoever writes code the fastest.

That used to be true.

Today?

Not so much.

AI can already generate thousands of lines of code in seconds.

The bottleneck is no longer typing.

The bottleneck is deciding:

👉 What should be built?

👉 Why should it be built?

👉 What tradeoffs should be made?

🧠 The Skill AI Can't See

Open any repository.

AI can analyze:

Classes
Functions
APIs
Dependencies

But it cannot easily understand:

Why a decision was made three years ago
Why a feature exists
Why users behave a certain way
Why the business chose one solution over another

That knowledge often lives outside the code.

In:

Meetings
Conversations
Product discussions
Customer feedback
Engineering tradeoffs

And that's where the real challenge begins.

⚙️ Code Shows What Happened

But not always:

👉 Why it happened.

For example:

Imagine AI finds this:

if(user.type === "legacy") {
   useOldPaymentFlow();
}

AI can explain what the code does.

But can it answer:

Why does the legacy flow exist?
What business risk does it avoid?
What customers depend on it?
What happens if we remove it?

Usually not.

Because those answers aren't in the code.

🚀 Modern Engineering Is Becoming Decision Engineering

As AI gets better at implementation...

Human value shifts upward.

From:

❌ Writing code

To:

✅ Making decisions

The most valuable developers increasingly spend time:

Understanding systems
Evaluating tradeoffs
Designing architecture
Clarifying requirements
Managing complexity

Not typing.

Thinking.

🔥 The Difference Between Coding and Engineering

AI is becoming very good at coding.

Engineering is different.

Engineering asks:

Is this scalable?
Is this maintainable?
Is this worth building?
What happens in six months?
What are we sacrificing?

Those questions rarely have perfect answers.

That's where judgment matters.

📚 Why Context Is Becoming More Valuable

Every large software system contains hidden context.

Things like:

Historical decisions
Business constraints
Team knowledge
Customer expectations

These shape the system.

But they rarely appear in source code.

This is why two developers can look at the same code and make completely different decisions.

Because context changes everything.

🤯 The Paradox of AI

The better AI becomes at writing code...

The more important non-coding skills become.

Sounds strange.

But think about it.

If implementation becomes easier:

👉 Decision quality becomes the differentiator.

The question is no longer:

"Can you build it?"

The question becomes:

"Should you build it this way?"

🎯 The New Competitive Advantage

In the AI era, valuable developers won't just be people who can code.

They'll be people who can:

Understand systems
Connect business goals with technology
Make good architectural decisions
Manage complexity
Communicate tradeoffs

These are skills AI can't simply extract from a repository.

💡 Final Thought

AI can read your code.

It can analyze your architecture.

It can generate implementations.

But one thing remains difficult:

👉 Understanding the human reasoning behind technical decisions.

And that's becoming one of the most valuable skills in software engineering.

Because the future isn't just about writing code.

It's about knowing why the code should exist in the first place.

And that's something no repository can fully teach.

AI #SoftwareEngineering #LLM #Developers #Programming #Architecture #TechLeadership #FutureOfWork #Coding #Engineering

I Built a “Battery Anxiety Simulator” Game… And 1% Battery Became a Horror Story 😭🔋

Md Mijanur Molla — Thu, 04 Jun 2026 10:36:19 +0000

We've all been there.

Your phone says:

🔋 15%

"No problem."

A few minutes later:

🔋 10%

Still fine.

Then suddenly:

🔋 5%

And your entire personality changes 😭

So I turned this universal experience into a game.

👉 Battery Anxiety Simulator

🎮 The Challenge

Your mission is simple:

Reach a charger before your phone dies.

That's it.

But the world keeps trying to destroy your battery.

⚠️ Every Decision Matters

Random events appear:

📞 Friend calls

Do you answer?

🎥 YouTube starts autoplay

Do you stop it?

Or watch "just one more video"? 😈

🗺️ GPS running in background

Turn it off?

Or ignore it and hope for the best?

😭 Things Get Worse Fast

As battery drops:

15% → Relaxed

10% → Concerned

5% → Panic

1% → Survival Mode Activated 💀

Then the game starts throwing chaos at you:

⚠️ Brightness jumps to 100%

💀 Hotspot turns on

😭 43 apps running in background

👀 Power bank found... but it's only 2% charged

💻 The Challenge Rules

Build everything using:

HTML
CSS
Vanilla JavaScript

And keep everything inside:

👉 ONE single HTML file

No frameworks.

No libraries.

Just pure frontend creativity.

🧠 Why I Like This Idea

Because everyone understands it instantly.

You don't need instructions.

You don't need tutorials.

The moment someone sees:

🔋 1% Battery

They already know the fear 😄

🚀 Explore More Creative Challenges

I've been exploring fun game-style coding challenges recently:

https://vibecodearena.ai/beattheheat?page=1&pageSize=10&sortBy=responses&sortOrder=desc&utm_source=external&utm_medium=vc3&utm_campaign=beattheheat

Some challenges test coding.

Some test logic.

This one tests your ability to survive modern life 😭

🎯 Final Thought

A phone at 100% gives confidence.

A phone at 1% reveals character.

The real question is:

Would you watch one more video at 2% battery? 😈🔋

Why Your AI Assistant Gets Lost in Large Repositories

Md Mijanur Molla — Thu, 04 Jun 2026 07:43:56 +0000

AI coding assistants are impressive.

They can:

Generate code
Explain functions
Write tests
Refactor components
Answer technical questions

For small projects, they often feel magical.

But something interesting happens when the repository gets bigger.

Really big.

Think:

Monorepos
Enterprise applications
Legacy systems
Multi-service architectures

Suddenly, your AI assistant starts giving strange answers.

And you find yourself thinking:

👉 "Wait... that's not how our system works."

So what changed?

Let's find out.

💡 The Problem Isn't Intelligence

Most people assume:

👉 AI gave the wrong answer because it isn't smart enough.

In reality, that's usually not the problem.

The real issue is:

👉 Lack of context.

AI can understand code.

But understanding an entire software system is a completely different challenge.

📚 Large Repositories Are More Than Files

Imagine a repository with:

5,000+ files
Hundreds of APIs
Shared libraries
Multiple services
Years of engineering decisions

Now ask:

👉 "How does user onboarding work?"

The answer may involve:

Frontend code
Backend services
Authentication flows
Event queues
Databases
Third-party integrations

The logic is spread across dozens of files.

Maybe hundreds.

🔍 Search Is Not Understanding

Many AI tools work by finding relevant files and code snippets.

That helps.

But there's a problem.

Finding something is not the same as understanding it.

For example:

You search for:

createUser()

You find 15 references.

Great.

But now you need to know:

Which one is actually used?
What service calls it?
What happens afterward?
What dependencies exist?

Suddenly:

👉 Search results are not enough.

🧩 Software Lives in Relationships

Large systems are built from relationships.

Examples:

Service A depends on Service B
Component X triggers Event Y
API Z updates Database Q

These connections matter.

And often they are more important than individual files.

That's where understanding becomes difficult.

🤯 The Context Window Problem

Another challenge is scale.

AI models have limited context windows.

Even when those limits are large...

Enterprise repositories are often larger.

Much larger.

A repository might contain:

Millions of lines of code
Years of commits
Thousands of dependencies

No AI can load everything at once.

So it must choose.

And sometimes it chooses the wrong context.

💀 Why AI Hallucinates in Large Codebases

This creates a common situation.

AI sees:

Some files
Partial relationships
Incomplete architecture

Then tries to fill in the gaps.

Sometimes correctly.

Sometimes not.

That's why you may get answers that look reasonable...

But are completely wrong for your project.

🚀 Why Developers Spend More Time Understanding Than Coding

In large systems, the hardest task is often not writing code.

It's understanding:

Existing architecture
Service dependencies
Data flow
Historical decisions

This is true for humans.

And it's true for AI.

Before changing code, you must understand the system.

🧠 The Missing Piece: Repository Memory

This is why concepts like:

Repository Memory
Knowledge Graphs
Code Graphs
Architectural Maps

are becoming more important.

Instead of treating code as isolated files...

They treat the repository as a connected system.

Now AI can understand:

Relationships
Dependencies
Data flow
Architecture

Not just raw code.

⚙️ Why Tools Like Graphify Exist

As repositories grow, developers face a new challenge:

👉 Knowing where things are is not enough.

You need to know:

How things connect
Why they exist
What depends on them

Tools that build repository memory help solve this problem.

They transform:

Files → Knowledge

And that's a big difference.

🎯 The Future of AI Coding

The next challenge for AI isn't generating code.

It's understanding systems.

Because real-world software is rarely about a single file.

It's about:

Architecture
Relationships
Context
Decisions

And those things don't fit neatly into a search result.

💡 Final Thought

Your AI assistant isn't getting confused because the repository is large.

It's getting confused because software isn't just code.

It's a network of relationships, dependencies, and decisions built over time.

And until AI understands those connections...

It will always struggle in large repositories.

Because reading code is one thing.

👉 Understanding a system is another.

AI #SoftwareEngineering #Monorepo #DeveloperTools #Codebase #LLM #AIAssistants #Architecture #Graphify #Programming