Marc Andreessen (the guy who called it when “software ate the world”) just pointed out what AI is doing to coding next.
“Everyone assumes AI coding means fewer hours… or leaving the profession. But almost everyone I know is working more hours.”
“There’s a new term in the Valley: the ‘AI vampire.’ You’re up all night AI coding because you’re so productive you can’t shut it off.”
“The top AI coders make $50M a year. They’ve found the philosopher’s stone.”
“Every company has a thousand projects they’ve wanted to build but never had the bandwidth. Now they can. This isn’t a blip—it’s going to intensify.”
PS: If this was useful, like + repost this tweet and follow @AiEvolutio58513 for the latest AI news.
See you in the next one:
These fanatics make the work hard for us ooo… hmmm. Every time someone stands before a crowd and tells people, “If someone insults the Prophet ﷺ, go and kill them and you’ll enter Jannah,” they don’t just misrepresent Islam they make it much harder for Muslims who are trying to explain the true teachings of our religion. Islam is not a religion where anyone can wake up, decide someone deserves to die, and carry out the punishment themselves. That is vigilantism, and Islam does not give individuals that authority. Many people hear about the Islamic rulings concerning blasphemy but never learn the conditions behind them. Those rulings were discussed by classical scholars within the framework of an established Islamic government, a qualified judiciary, strict rules of evidence, the rights of the accused, and due process. They were never a license for ordinary people to become judge, jury, and executioner.
The Prophet ﷺ himself was insulted repeatedly during his lifetime. He was mocked, called a liar, a magician, and a madman. Yet his response was often patience, forgiveness, and inviting people to the truth. There were also instances involving treason, warfare, or other serious crimes where legal action was taken, but those cannot honestly be reduced to, “Someone insulted the Prophet, so anyone can kill them.”
If we truly love the Prophet ﷺ, we should defend his honour with knowledge, wisdom, good character, and by following his Sunnah not by encouraging mob justice. When people preach violence without explaining the principles of justice, authority, and due process in Islam, they hand Islam’s critics an easy target and create confusion among Muslims and non-Muslims alike. And to our Christian brothers and sisters, I can see many of the comments expressing anger, disappointment, and even disgust. I understand why such a statement would be deeply troubling. However, I respectfully ask that you do not judge Islam by the words of one preacher or one viral video. Judge Islam by its authentic sources and by the teachings of the Prophet Muhammad ﷺ as a whole. Just as Muslims would not want Christianity to be judged solely by the actions or statements of a single pastor, extremist, or self-proclaimed leader, we ask for the same fairness. Every faith has individuals whose words or actions do not represent the mainstream teachings of their religion. If you disagree with Islam, do so based on what Islam actually teaches not on sensational clips taken in isolation. We may disagree in our beliefs, but we can still discuss them with respect, honesty, and evidence. Let’s reject hatred, reject incitement to violence, and choose dialogue over division. Ghana has long been an example of peaceful coexistence between Muslims and Christians. Let’s protect that legacy instead of allowing the words of a few individuals to divide us. May Allah guide us all to what is true and grant us wisdom in our speech and actions.
The silent killer of web apps:
Enterprise overengineering.
Some devs think they're building the next Amazon.
So they put CQRS, event buses, mediators, and five service layers into a simple CRUD app.
The result?
Every change requires going through:
- 3 interfaces,
- 17 files,
- across 5 different projects
just to return an additional field from your database.
Meanwhile, productivity tanks.
Features that should take hours now take weeks.
And all because someone thought "more layers" meant "more professional."
Here's the truth:
You don't need enterprise architecture for an app that 500 people use.
Complexity should solve real problems.
Not create them.
A better approach:
1. Start simple.
2. Scale complexity only when the app demands it.
3. Build for today. Not for some fantasy scale that may never come.
Complexity isn't a badge of honor.
It's a tax on everyone who comes after you.
Building a collaborative real-time text editor is an engineering trap.
Most developers think it is just passing websockets back and forth. Then two users type at the same millisecond, the document state diverges, and you are stuck in a distributed systems nightmare.
Here is how modern apps handle concurrency without losing data:
AGI is not coming.
We are nowhere near AGI. What we have today is inference, not learning.
Models get trained once on huge fixed datasets, then frozen. You ask questions, they remix patterns they already saw. Nothing updates. Nothing sticks. Talking to the model does not make it smarter. It does not learn from you. Ever.
Learning is still slow, expensive - and offline.
Look at self driving. You drive around a pothole, make a U turn, and come back. The car’s AI does not learn that you just solved that exact problem. It reacts the same way every time using sensors and rules. Do this 20 times a day and it still has zero memory that the pothole exists. It just re sees it. That is why edge cases never die. There is no local learning. No accumulation.
No 'oh yeah, I’ve seen this before'
LLMs work the same way. Tell it your name and it does not remember. The only reason it looks like memory is because scaffolding keeps shoving your name back into the prompt every time and sanitizing the output.
The model itself has no idea who you are and cannot learn from interaction. It is structurally incapable.
And the scaffolding is the worst part. It is pure duct tape. Just prompts on prompts on prompts around a frozen model. When something breaks, nobody fixes learning. They add another layer. Another rule. Another retry. Another evaluator model judging the first model.
So you end up with systems that are insanely complex but mentally shallow. Debugging is hell because behavior comes from hack interactions, not a learnable core. Tiny prompt tweaks cause wild behavior shifts. Latency goes up. Costs go up. Reliability goes down. None of this compounds into intelligence. It just hides the cracks.
Until we have real persistent learning and real memory inside the system, there is no AGI.
LLMs are not built for this. You cannot prompt your way out of it. You need a totally different architecture. Yann LeCun is right.
And even then, what architecture can actually learn online, store memory, and stay stable on today’s hardware?
Best case, maybe 5-10 yrs.
Right now it is all inference. It looks magical, but the emperor has no clothes. A lot of people see it. Almost nobody says it out loud.
“If I’m taking care of you as a woman and paying all your bills, I have the right to control you. You can’t stop me from checking your phone, and I won’t allow you to wear revealing clothes.”
— Man says
My recommended steps for crushing your next backend technical interview
1. Basics
Know your fundamentals cold: HTTP, REST semantics, status codes, idempotency, retries, timeouts, pagination, auth (sessions/JWT/OAuth), basic SQL, indexes, transactions, isolation levels.
2. Concurrency + Performance
Be comfortable with threads/goroutines, locks, race conditions, connection pools, backpressure, batching, async workflows, and why p95/p99 matters more than averages.
3. Storage + Data modeling
Model data cleanly: schemas, constraints, denormalization tradeoffs, read vs write paths, caching strategy, migrations, and how you prevent “works locally, dies in prod” issues.
4. Distributed systems essentials
Have sharp instincts around consistency, replication, sharding, leader/follower, partitions, consensus basics, message queues vs streams, at-least-once delivery, ordering, and deduplication.
5. System design primitives
Every design reduces to a few building blocks: load balancer, stateless API tier, cache, queue, DB, blob store, search index, background workers. Show you can assemble these with clear tradeoffs.
6. Failure-mode thinking
Assume things break: downstream timeouts, partial failures, overload, deploy rollbacks, bad data, poisoned messages, thundering herds. Explain what happens and how your system degrades safely.
7. Observability + operations
Talk like someone who has shipped: logs/metrics/traces, correlation IDs, SLOs, alerting, dashboards, runbooks, canary releases, feature flags, capacity planning.
8. Problem solving approach
Clarify requirements early, define scale with numbers, draw the request flow, identify bottlenecks, and then iterate. Don’t jump to Kafka/K8s — justify them.
9. Communication under pressure
Think out loud. State assumptions. When stuck, narrow the problem, propose options, pick one, and explain the tradeoff. Interviewers reward reasoning more than perfection.
10. Practice like it’s production
Do mock interviews, then write a 1-page debrief: what you missed, what confused you, and the “default framework” you’ll use next time. That feedback loop is the cheat code.
Show how you think, reason, analyze — and don’t be scared to fail. The strongest signal in senior interviews is calm clarity when the problem gets messy.