DEV Community: Ifedayo Agboola

Fixing the “Module not found: Can't resolve '@/…'” Error in Next.js (and Why It Happens on Netlify)

Ifedayo Agboola — Tue, 28 Oct 2025 16:51:04 +0000

Have you ever pushed a perfectly working Next.js app to Netlify and suddenly got a wall of red text saying:

Module not found: Can't resolve '@/components/Button'

Don’t worry — you didn’t break anything.

I ran into the same issue while deploying Sellexa, a social-commerce marketplace for minority entrepreneurs, and learned that the problem isn’t your code — it’s how your environment handles path aliases and case sensitivity.

Let’s unpack it.

Why It Happens

This error usually means one of two things:

1. Your local environment is forgiving — Netlify’s isn’t.

macOS and Windows use case-insensitive file systems, but Netlify’s Linux servers are case-sensitive.

So:

import Button from "@/components/ui/button";

will work locally even if your file is named Button.tsx,

but it fails on Netlify because button ≠ Button.

2. Your alias (`@`) isn’t configured for the build

Many Next.js starters and tutorials assume your editor or TypeScript magically knows what @ means.

But unless you explicitly tell both TypeScript and Webpack, Netlify’s build system will have no clue how to resolve it.

The Fix

Follow these four steps and you’ll never see this error again.

Step 1 — Add paths to `tsconfig.json`

At the project root, open (or create) tsconfig.json:

{
  "compilerOptions": {
    "baseUrl": ".",
    "paths": {
      "@/*": ["./src/*"]
    }
  }
}

This tells TypeScript and your IDE that @ refers to your /src folder.

Step 2 — Add a Webpack alias in `next.config.mjs`

Next.js still needs to understand the alias during the production build.

Open next.config.mjs and add this snippet:

import path from "node:path";

/** @type {import('next').NextConfig} */
const nextConfig = {
  webpack: (config) => {
    config.resolve.alias = {
      ...(config.resolve.alias ?? {}),
      "@": path.resolve(process.cwd(), "src"),
    };
    return config;
  },
};

export default nextConfig;

Now @ will resolve properly both locally and on Netlify.

Step 3 — Match file and import casing

On Linux, Button.tsx and button.tsx are different files.

Run this to double-check your imports:

git grep -i "@/components"

Ensure your import casing matches your filenames exactly.

Step 4 — Clear cache and redeploy

In Netlify:

Go to your site → Deploys
Click “Trigger deploy” → “Clear cache and deploy site”

A clean build after the alias fix should succeed immediately.

Bonus — If you see this with Supabase

If your logs say:

Module not found: Can't resolve '@/integrations/supabase/client'

It just means the client.ts file is missing.

Here’s the correct structure:

src/
  integrations/
    supabase/
      client.ts

import { createClient } from "@supabase/supabase-js";

export const supabase = createClient(
  process.env.NEXT_PUBLIC_SUPABASE_URL!,
  process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
);

Quick Summary

Problem	Root Cause	Solution
Alias error on build	`@` not configured	Add alias in `next.config.mjs`
Works locally, fails on Netlify	Case sensitivity	Match file & import names
Supabase client error	Missing file	Add `client.ts` in correct folder
Still fails after fix	Cached build	Clear cache & redeploy

Lessons Learned

Linux is unforgiving about file casing.
Your IDE might “see” @/ paths — but Webpack won’t unless configured.
Always define aliases in both tsconfig.json and next.config.mjs.
CI/CD issues are often environmental, not code-related.

Final Thoughts

When I first hit this issue, I wasted hours hunting for missing files that weren’t missing.

One line in next.config.mjs fixed everything.

If you’re facing this same problem, copy these configs and save yourself the headache.

Next time your Netlify build goes red, you’ll know exactly what to do.

Author: Ifedayo “Sam” Agboola

Founding Engineer — Sellexa.app

Building inclusive tech, one deploy at a time.

How To Build Your Own Cloud

Ifedayo Agboola — Mon, 22 Sep 2025 09:10:48 +0000

Lessons 1-3

This post is part of my “Self-Hosting from Scratch” series.

Tired of paying AWS, Render, or Fly.io while juggling multiple projects? I’m documenting how I built my own self-hosting setup, step by step, with all the mistakes, fixes, and lessons learned along the way.

Series roadmap:

Lessons 1–3: Hardware, Ubuntu Setup & Security
Lesson 4: Docker & Docker Compose
Lesson 5: Reverse Proxy with Traefik
Lesson 6: Cloudflare Tunnel (public HTTPS without router configs)
Lesson 7: Smoke Tests with Whoami
Lesson 8: Postgres in Docker (volumes, healthchecks, backups)
…and more coming soon

Bookmark this series and follow along. By the end, you’ll be running your own server confidently

End goal for today: you’ll finish with a clean, secure Ubuntu server you can log into from your laptop using SSH keys, with a firewall and automatic security updates. This is the bedrock we’ll reuse for Docker, Traefik, Cloudflare Tunnel, databases, and file storage in later lessons.

I’ll teach this the way I built mine, so you understand why each command exists, when to use it, and how to fix common mistakes without panic.

Roadmap (today & next)

Today (Lessons 1–3):

Hardware choices (home server vs small PC vs VPS)
Install Ubuntu Server (LTS) & first boot
Secure access: SSH keys, firewall, updates

Coming next (in order):

Docker & Compose → Traefik → Cloudflare Tunnel → “whoami” smoke test → Postgres → Prisma → Node/Express API → Cloudflare R2/S3-compatible storage → presigned uploads → observability → clean dev/prod separation.

Throughout the series I’ll also call out real errors we hit (e.g., Traefik 404s from an unhealthy container, Prisma OpenSSL mismatch, S3 CORS quirks) and how we fixed them, so you won’t burn a day like we did.

LESSON 1: Hardware (pick what fits your budget)

The decision tree (plain English)

£0–£50: Reuse an old PC or laptop.
- Pros: free, quick start. Cons: power draw, older disks.
£120–£300: Refurbished mini PC (Lenovo Tiny, Dell Micro, Intel NUC).
- Sweet spot: 16–32 GB RAM, 256+ GB SSD, quiet, low power.
£5–£10/mo: VPS (Hetzner/Contabo/Linode).
- Pros: always-on, public IP. Cons: monthly cost.

Minimum specs for this course

CPU: any x86_64 from the last ~10 years
RAM: 8 GB (16 GB if you’ll run DB + object storage + search)
Disk: 128 GB SSD (NVMe ideal). Start simple (single disk).
Network: wired ethernet if possible (Wi-Fi works, but is fussier)

Quality-of-life add-ons (optional)

UPS (mini battery) so a power blip won’t corrupt databases.
Label the box with its hostname & static IP; you’ll thank yourself later.

Checkpoint: pick your machine. If it’s at home, plug in ethernet. If it’s a VPS, note the provided IP and login.

LESSON 2 — Ubuntu Server (Install & first boot)

We’ll install Ubuntu Server 24.04 LTS because it’s stable and well-supported by Docker.

2.1 Create install media

Download the Ubuntu Server 24.04 LTS ISO.
Flash it to a USB stick with balenaEtcher (or Rufus on Windows).

* Why: it writes the ISO in a bootable format safely.

2.2 BIOS/UEFI boot

Plug the USB into your server, power on, press F12 / F2 / DEL / ESC to open the boot menu, choose the USB device.

2.3 The installer (what to pick & why)

Keyboard/Language: defaults usually fine.
Network: DHCP is OK for now (we’ll use Cloudflare Tunnel later, so no port-forwarding).
Storage: “Use entire disk”. LVM optional. Start simple.
User: create an admin user (this account gets sudo).
OpenSSH: Enable it (lets you log in remotely).
Reboot, remove USB.

If you see a hostname prompt, choose something memorable, e.g., blackscript-server or orion.

2.4 First login (locally or over SSH)

On the server screen you’ll see an IP address (e.g., 192.168.1.50).

From your laptop/desktop terminal:

ssh youruser@192.168.1.50

ssh opens a secure shell to the server.
First time, you’ll be asked to trust a fingerprint → type yes, then your password.

2.5 Update the system (security baseline)

sudo apt update
sudo apt upgrade -y

apt update refreshes the package list.
apt upgrade -y applies upgrades immediately.

Checkpoint: run hostnamectl (see your hostname) and ip a | grep inet (confirm the IP). If SSH works and updates completed, you’re ready for security hardening.

LESSON 3 — Secure Access (SSH keys, firewall, updates)

We’ll get you to a place where you log in with a key (not a password), a firewall protects the box, and security updates auto-apply.

⚠️ Safety tip: keep one SSH session open while you change settings. If you misconfigure, you still have a lifeline.

3.1 Generate an SSH key (on your laptop)

If you don’t have one already:

ssh-keygen -t ed25519 -C "you@example.com"

What it does:

Creates a keypair in ~/.ssh/ (id_ed25519 + id_ed25519.pub).
-t ed25519 is a modern, secure key type.
-C adds a label so you recognize it later.
Set a passphrase when prompted (local theft protection).

3.2 Copy your key to the server

Still on your laptop:

ssh-copy-id youruser@192.168.1.50

What it does:

Appends your public key to the server’s ~/.ssh/authorized_keys.
After this, your key can log in without typing the server password every time.

If ssh-copy-id isn’t available, you can copy manually:

cat ~/.ssh/id_ed25519.pub | ssh youruser@192.168.1.50 "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys"

3.3 Test key login

Close your SSH session and reconnect:

ssh youruser@192.168.1.50

If it logs you in without asking the server password (it may ask your key passphrase), you’re good.

3.4 Enable & configure the firewall (UFW)

sudo ufw allow OpenSSH
sudo ufw enable
sudo ufw status

allow OpenSSH opens port 22 so you don’t lock yourself out.
enable turns the firewall on.
status shows allowed rules.

Later, when we run Traefik, we’ll open HTTP (80). With Cloudflare Tunnel you often don’t need to open public ports at all, but we’ll cover both patterns.

3.5 Harden SSH (disable password & root logins)

sudo nano /etc/ssh/sshd_config

Find/set:

PasswordAuthentication no
PermitRootLogin no

Save and restart SSH:

sudo systemctl restart ssh

Why:

Password logins are bruteforced on the public internet. Keys are safer.
Root login disabled reduces blast radius.

Recovery if you lock yourself out:

Use the console/KVM/monitor+keyboard to revert PasswordAuthentication yes temporarily.

Or re-enable via cloud provider console.

Always keep one SSH window open while testing changes.

3.6 Automatic security updates

sudo apt install -y unattended-upgrades
sudo dpkg-reconfigure -plow unattended-upgrades

Installs a service that applies security updates automatically.
The reconfigure step enables it persistently.

You can inspect logs in /var/log/unattended-upgrades/.

Bonus safety nets (optional but nice)

A. Create a friendly SSH alias on your laptop

Add to ~/.ssh/config:

Host home-server
  HostName 192.168.1.50
  User youruser
  IdentityFile ~/.ssh/id_ed25519

Now you can do ssh home-server.

B. Timezone & NTP (useful for logs)

sudo timedatectl set-timezone Europe/London
timedatectl

C. Basic fail2ban (blocks repeated auth failures. Handy if you expose SSH)

sudo apt install -y fail2ban

Defaults are sensible; we can tune later if you open SSH to the world.

“What can go wrong?” (real mistakes we’ve made)

Locked myself out of SSH.

I disabled password logins before confirming key auth worked.

Fix: Console in, set PasswordAuthentication yes, restart ssh, copy key correctly, then disable again.
UFW dropped my SSH.

I enabled UFW without allowing OpenSSH first.

Fix: Console in, sudo ufw allow OpenSSH, sudo ufw enable.
No network after reboot.

Router changed IP via DHCP.

Fix: Check the screen/ip a for the new IP. Later we’ll set a DHCP reservation or a static IP.

Bigger errors we’ll meet later (and solve):

Traefik 404s because the backend container was unhealthy (our healthcheck hit a non-existent /healthz).

Prisma OpenSSL mismatch (client built for openssl-1.1.x but runtime had 3.0.x). We fixed it by setting binaryTargets = ["native","debian-openssl-3.0.x"] and generating in the build image.

S3 CORS headaches on MinIO; we worked around by injecting CORS at Traefik.

You’ll see those fixes in context when we reach those lessons.

Recap (what you achieved today)

Picked sensible hardware that won’t wreck your wallet.
Installed Ubuntu Server 24.04 LTS the right way (with SSH).
Logged in from your laptop, enabled a firewall, switched to key-based auth, and turned on automatic security updates.

This is the foundation. With this done, everything else (Docker, Traefik, tunnels, DBs) becomes straightforward and repeatable.

Your First AI Agent: A Clear, Practical Path

Ifedayo Agboola — Wed, 27 Aug 2025 13:39:00 +0000

Most “AI agent” advice is either super abstract or painfully over-engineered. Five days ago I saw a concise blueprint on Reddit that nailed the path. This post paraphrases and expands that idea into a copy-paste plan you can actually ship.

Credit: Inspired by a great post on r/AgentsOfAI by u/Icy_SwitchTech titled “Building your first AI Agent; A clear path!”. I’ve adapted and expanded it with my own notes, checklists, and code stubs.

Why agent projects stall

The problem is vague (“general agent” syndrome).
Tooling decisions come before the use-case.
Teams jump to frameworks before the basic loop works.
Memory/vector DBs get added on day one (you probably don’t need them yet).

The cure is boring and effective: ship one tiny, single-purpose agent end-to-end.

The 8-Step Path (with mini checklists)

1) Pick one very small, very clear job

Examples you can ship this week:

Book a doctor’s appointment from a hospital website.
Summarize unread emails from the last 24 hours and send a recap.
Watch job boards and forward matches with a relevance score.
Rename and file PDFs in a set folder using simple rules.

Checklist

The job has a binary “done/not done”.
One user, one trigger, one output.
You can demo it in under 2 minutes.

2) Choose a base LLM (don’t train anything yet)

Use a capable hosted model (e.g., GPT, Claude, Gemini) or a solid open-source model if you’re self-hosting. Focus on structured outputs (JSON) and tool-use ability.

Checklist

Model supports function/tool calling or you can structure prompts to emit JSON.
You’ve tested a few sample prompts and validated cost/latency.

3) Decide how it touches the outside world (the part most people skip)

List exactly which actions your agent is allowed to do:

Web scraping/browsing (Playwright, Puppeteer, or site APIs).
Email API (Gmail/Outlook).
Calendar API (Google/Outlook).
File I/O (read/write PDFs, CSVs, disk).
Internal service calls (HTTP/GraphQL).

Checklist

Every action has one clear function with strict inputs/outputs.
You’ve written mock versions you can test offline.

4) Build the skeleton workflow (before any frameworks)

The heartbeat is: model → tool → result → model until you get a final answer.

Checklist

System prompt defines role, constraints, JSON schema, and stop conditions.
A loop executes selected tools and feeds results back to the model.
Clear exit condition (e.g., “status: done” with a final payload).

5) Add memory carefully (later, and only if needed)

Short-term chat context is enough for many tasks. If you must remember across runs, start with a tiny JSON/SQLite file keyed by user/task. Bring in vector DBs only when retrieval becomes the bottleneck.

Checklist

Start with ephemeral memory (last few messages).
If persistence is required, begin with JSON/SQLite, then consider RAG.

6) Wrap it in a simple interface

CLI first to prove behavior, then a minimal UI:

A one-screen web dashboard (Flask/FastAPI/Next.js).
A Slack/Discord bot if your users live there.
A cron/worker for scheduled runs.

Checklist

One button to run, one place to read results.
Logging visible in the UI (status + latest tool step).

7) Iterate in tiny cycles

Run real tasks, find the brittle spots, patch, repeat. Expect many cycles!

Checklist

Log every tool call and model message.
Keep a “golden set” of 5–10 tasks; the agent must pass them all before you add features.

8) Keep scope under control

A single, boring, reliable agent beats a “universal agent” that fails randomly.

Checklist

No new tools until the agent is stable for a week.
Any new feature must ship behind a flag and pass the golden set.

Minimal code skeletons

A. Python (requests + your tools)

# minimal_agent.py
import json, time
from typing import Dict, Any

# 1) Your tools
def get_unread_emails() -> Dict[str, Any]:
    # TODO: call Gmail/Outlook API
    return {"emails": [{"from": "a@b.com", "subject": "Hi", "body": "…"}]}

def send_summary(text: str) -> Dict[str, Any]:
    # TODO: send via email/Slack
    return {"sent": True, "length": len(text)}

TOOLS = {
    "get_unread_emails": {"fn": get_unread_emails, "schema": {"type": "object", "properties": {}}},
    "send_summary": {"fn": send_summary, "schema": {"type": "object", "properties": {"text": {"type": "string"}}}},
}

# 2) LLM call (replace with your provider’s SDK)
def llm(messages):
    # TODO: call your model with function/tool calling enabled
    # Return either {"tool": {"name": "tool_name", "args": {...}}} or {"final": {...}}
    raise NotImplementedError

SYSTEM = {
    "role": "system",
    "content": (
        "You are an email-summarizing agent.\n"
        "Allowed tools: get_unread_emails(), send_summary(text).\n"
        "Always return JSON. Finish with: {\"final\": {\"status\": \"done\", \"summary\": \"...\"}}."
    )
}

def run_agent():
    messages = [SYSTEM, {"role": "user", "content": "Summarize unread emails from the last 24h and send me a recap."}]
    for _ in range(10):
        out = llm(messages)
        if "final" in out:
            return out["final"]

        tool_name = out["tool"]["name"]
        args = out["tool"].get("args", {})
        result = TOOLS[tool_name]["fn"](**args)
        messages.append({"role": "tool", "name": tool_name, "content": json.dumps(result)})
        time.sleep(0.1)

if __name__ == "__main__":
    print(run_agent())

This is intentionally minimal: replace llm() with your provider, wire real tool functions, and control the loop exit condition in the system prompt.

B. TypeScript (Node) shape you can grow

// agent.ts
type Message = { role: "system" | "user" | "assistant" | "tool"; name?: string; content: string };

type ToolResult = Record<string, unknown>;
type ToolFn = (args?: Record<string, unknown>) => Promise<ToolResult> | ToolResult;

const tools: Record<string, { fn: ToolFn }> = {
  getUnreadEmails: { fn: async () => ({ emails: [] }) },
  sendSummary: { fn: async (args) => ({ sent: true, length: (args?.text as string)?.length || 0 }) },
};

async function llm(messages: Message[]): Promise<any> {
  // Call your LLM with tool/function calling enabled.
  // Return either { tool: { name: string, args: object } } or { final: object }.
  throw new Error("Implement me");
}

const SYSTEM: Message = {
  role: "system",
  content:
    "You are an email-summarizing agent. Allowed tools: getUnreadEmails(), sendSummary(text). " +
    'Always output JSON. Finish with {"final":{"status":"done","summary":"..."}}.',
};

export async function runAgent() {
  const messages: Message[] = [SYSTEM, { role: "user", content: "Summarize unread emails from the last 24h and send me a recap." }];
  for (let i = 0; i < 10; i++) {
    const out = await llm(messages);
    if (out.final) return out.final;

    const { name, args } = out.tool;
    const result = await tools[name].fn(args);
    messages.push({ role: "tool", name, content: JSON.stringify(result) });
  }
  throw new Error("Loop limit reached");
}

Prompts that keep agents honest

Use a terse system prompt that sets role, allowed tools, JSON schema, exit rule, and guardrails:

You are a single-purpose agent that <do the one job>.
Allowed tools: <toolA(args)>, <toolB(args)>. Never invent tools.
Always speak JSON. On each step, either:
{"tool":{"name":"<toolName>","args":{...}}}
or
{"final":{"status":"done","data":{...},"notes":"..."}}.
Stop when status=="done". If you cannot proceed safely, return:
{"final":{"status":"blocked","reason":"..."}}

A few good first agents to build

Calendar concierge: turn natural language into real calendar events + email invite.
Inbox digester: summarize unread emails into one daily note + links.
Lead enricher: take a CSV of company names, fetch sites/socials, return a profile sheet.
Content filer: rename/organize PDFs based on detected title/date/vendor.

Pitfalls & guardrails

Don’t add memory too early. JSON or SQLite beats a whole vector stack at the start.
Constrain tools. Narrow inputs, validate aggressively, and log everything.
Define “done”. Without a crisp exit condition, agents meander and cost you tokens.
Golden set. Keep a fixed set of scenarios the agent must pass before adding features.

What this buys you

Once you’ve shipped one specific agent end-to-end, every next agent gets easier:

you already know how to frame the problem, wire tools, design the loop, and ship a tiny UI.

If you try this path, I’d love to see what you build. Drop a comment or ping me. Happy to review prompts or tool boundaries.

PS: Attribution

This article paraphrases and extends a concise framework shared by u/Icy_SwitchTech on r/AgentsOfAI: “Building your first AI Agent; A clear path!” All mistakes, expansions, and code here are mine.

Originality, Creativity, Visibility: The Three Multipliers of Modern Success

Ifedayo Agboola — Fri, 08 Aug 2025 13:14:49 +0000

Why skills alone don't compound and what does.

Thesis:

In a noisy, fast moving world, skills alone don't compound.

What compounds is your ability to:

Think from first principles
Turn those ideas into usable things
Make your value easy to find

Call them Originality, Creativity, and Visibility. Together, they create career momentum.

Why These Three And Why Now

We are drowning in information but starving for insight.

Every morning, you probably scroll through LinkedIn, Twitter, or news apps, consuming dozens of articles and posts.

Here is the trap: all that information blends into noise. You feel informed but cannot remember a single compelling idea by lunch.

This is the modern paradox: endless input with zero original output.

Originality is how you break through that noise without shouting.

Creativity is how you convert conversations into something real.

Visibility is how you make sure your best work is seen.

Together, they form a flywheel. Original thinking feeds creative outputs.

Consistent outputs power your visibility.

Visibility attracts feedback and collaborators that sharpen your thinking.

1) Originality: Stop Consuming, Start Connecting

What it is: Seeing a problem differently enough to change how you solve it.

Why it matters: If your perspective sounds like everyone else's LinkedIn post, your work competes on price, speed, or luck. A clear point of view makes you memorable.

Example:

Netflix beat Blockbuster not because they had more data, but because they reframed the problem.

Blockbuster saw a rental business. Netflix saw that people hated late fees more than they loved browsing store aisles. That insight changed everything.

Everyday mistake:

Consuming content like it is your job. Reading endless productivity hacks, leadership lessons, and industry trends without forming your own views.

How to build it:

• Read outside your lane. Explore psychology, history, or biology to spark fresh thinking.

• Write to think. Capture your reactions, not just quotes.

• Test tiny hunches. Spend 30 minutes running a small experiment instead of debating endlessly.

Signal to aim for: Someone can summarize your stance in one sentence.

2) Creativity: Build Something, Anything

What it is: Combining existing pieces in useful, new ways.

Why it matters: Employers and clients do not need more information. They need new combinations that solve problems.

Example:

Sara Blakely founded Spanx by cutting the feet off her pantyhose. She did not invent new fabric or technology. She solved her own problem in a simple way, which became a billion dollar company.

Everyday mistake:

Overthinking instead of overdoing. Waiting for perfect conditions while others ship rough versions and learn.

How to build it:

• Set constraints. Force creative leaps by working within tight limits.

• Steal from other worlds. Adapt patterns from unrelated industries.

• Make the smallest thing that works. Build prototypes, not just plans.

Signal to aim for: Every 30 days, something new exists with your name on it.

3) Visibility: Show Up Where People Already Are

What it is: Systematically sharing your work where your audience hangs out.

Why it matters: The best work cannot help you if it stays hidden. Visibility multiplies luck.

Example:

Gary Vaynerchuk grew his family's wine shop to 60 million dollars by showing up daily on YouTube, teaching people about wine. Consistency built trust, audience, and revenue.

Everyday mistake:

Creating in private, then wondering why nobody notices.

How to build it:

• Pick one channel. Focus before expanding.

• Borrow trust. Partner with people or platforms that already have the audience you want.

• Make discovery easy. Ensure your best work is one click away.

Signal to aim for: A stranger can find your latest work in two clicks and contact you in one.

How They Work Together

The loop in action:

Notice something others miss (originality)
Build a small test or example (creativity)
Share what you learned (visibility)
Gather feedback, sharpen your thinking, and repeat

Reputations grow not from one big moment, but from people watching you think, build, and share over time.

Your 30 Day Start

Weekly rhythm (90 minutes total):

• Monday (30 min): Read outside your field and capture three surprising thoughts.

• Wednesday (30 min): Build something small and tangible.

• Friday (30 min): Share it publicly with insights on what worked and what did not.

Monthly check:

• Did I share a clear, different perspective?

• Did I create something new?

• Can people find it easily?

If any answer is no, that is your focus next month.

What Trips People Up

• Waiting for the big idea instead of starting small

• Confusing busy with productive — hours spent does not equal value created

• Broadcasting without listening

• Fear of looking stupid and staying invisible as a result

Start Small, Start Now

Success is not just about what you know or how hard you work.

It is about thinking differently, building consistently, and sharing openly.

Netflix saw friction where others saw rentals.

Spanx saw solutions where others saw problems.

Wine Library TV saw education where others saw only sales.

The pattern works anywhere: Think differently → Build something → Share it → Repeat.

Pick one small cycle and start this week.

Your future self will thank you.

Beyond Coding: How to Survive and Thrive in the AI Revolution

Ifedayo Agboola — Tue, 15 Jul 2025 10:18:42 +0000

“If you want to know what life’s like when you’re no longer the apex intelligence… ask a chicken.” – Geoffrey Hinton

That line did something to me. Let it do the same to you.

Because the truth is: The world you were trained for no longer exists.

No, I’m not trying to scare you. I’m telling you the truth.

For over a decade, I thrived in tech. Then boom one day, my role was dissolved. Downsizing. Restructuring. Sales pressure.

Just like that. Gone.

Then I started looking for jobs… but the market I once knew had changed.

So I did what anyone with sense would do, I researched.

What changed? What’s working now? Where are we headed?

And guess what I found?

Everything is shifting. And it’s shifting fast.

Let me hit you with a few realities: ⁃ 90% of software engineers may no longer need to write code. ⁃ Only 1–2% will stay hands-on. ⁃ Coding isn’t useless, but it’s no longer the golden ticket.

This shift is beyond just a tech revolution.

The first industrial revolution replaced muscle. This one? It’s coming for the mind.

Now let’s bring it back home… Still think your resume is enough?

Here’s the thing: • You were trained for a world that has expired. • You were taught to memorize, obey, and repeat, not to question, innovate, or create. • You’ve been learning, but still feel stuck because the rules have changed.

So, what do we do now?

You evolve. That’s what.

And here’s what I’ve seen work firsthand:

Get LOUD. Be SEEN. Build that brand. Stop waiting for a recruiter to save you. My own partner grew her LinkedIn from 3k to almost 10k in a few months. No fancy CV, just showing up with value.

Now? Speaking gigs. Job offers. Collaboration deals. DMs flying in.

She’s not doing magic. She’s just posting value consistently.

Only 1% of LinkedIn users post every week.
2.7 billion people use YouTube — only 4% create.

Visibility >>> everything.

Learn Entrepreneurial Skills. AI has made it possible to build full systems with just your phone.

You can now write, design, automate, launch products, even run entire businesses alone.

Skills are the new currency. Not just fancy certificates.

Network, even if you hate it. Use this intro cheat sheet to connect with people: • Name: Who you are • Same: What field you’re in • Fame: What makes you credible • Aim: What you’re working on now • Game: Your long-term vision

Screenshot this. Use it everywhere. Thank me later.

Critical thinking, creative direction, emotional intelligence, these are the final weapons we have left.

The rest? AI is knocking already.

This is your sign to reinvent yourself before the system forces you to.

To show up before the opportunities run out.

To build something before you’re left behind.

Want help?

Drop “TOOLS” in the comments and I’ll send you a curated AI tools list I’ve been working with.

It’s helped me. It might just change the game for you too.

And remember: You can’t learn to ride a bike by reading about it. You have to jump on.

The Developer's Guide to Surviving the AI Revolution

Ifedayo Agboola — Tue, 08 Jul 2025 09:25:34 +0000

What I learned after getting laid off and researching how tech careers are changing forever

The Wake-Up Call

Three months ago, I got laid off from my software engineering role due to company downsizing. Like many developers, I thought I'd just dust off my resume, showcase my technical skills, and land another position quickly.

I was wrong.

The job market I entered was completely different from the one I left. After weeks of intense research into the current state of tech careers, I discovered something that fundamentally changed how I think about being a developer in 2024.

The Uncomfortable Truth About Coding

Here's what the data is showing:

90% of software engineers will stop writing code within 5 years
Only 1-2% will remain in pure coding roles
The traditional software development career path is rapidly disappearing

But here's the paradox: coding is still a valuable skill to learn.

Wait, what?

This Isn't Your Typical Tech Revolution

Every time someone brings up AI replacing developers, others argue, "We've seen this before with automation." But this time is fundamentally different.

Previous technological revolutions replaced muscle power (Industrial Revolution).

AI is replacing intellectual power — the very thing that made us valuable as knowledge workers.

Geoffrey Hinton, the "godfather of AI," put it best:

"We're not used to thinking about things smarter than us. If you want to know what life's like when you're not the apex intelligence, ask a chicken!"

The Real Questions We Need to Ask

As developers, we're facing two critical questions:

1. Can we slow down AI development?

Short answer: No.

The reality is:

Countries are competing globally (US vs China vs EU)
Companies are racing for competitive advantage
Open-source AI development is accelerating
The genie is already out of the bottle

2. Can we coexist with AI?

This is where it gets interesting.

The experts are divided:

Yann LeCun (Meta's Chief AI Scientist): AI will remain obedient tools
Eliezer Yudkowsky (AI Safety researcher): We're heading toward existential risk

But regardless of who's right, AI is here to stay.

The Skills Gap Crisis

Here's the problem most developers are facing:

We're being trained for a world that no longer exists.

Traditional computer science education focuses on:

Algorithms and data structures
Systems design
Code optimization
Technical problem-solving

But the market now demands:

AI collaboration skills
Product thinking
Business acumen
Personal branding
Entrepreneurial mindset

The Developer's Survival Strategy

After researching successful tech professionals who are thriving in this transition, I've identified three critical strategies:

1. Build Your Technical Brand

The Reality Check:

Only 3% of LinkedIn users post regularly
Only 1% post weekly
You're not competing with millions of developers — you're competing with the 3% who are visible

The Formula: To become memorable in your niche, you need the 7114 formula:

Hours of engagement with your audience
Interactions across different touchpoints
Different platform engagements (GitHub, Twitter, LinkedIn, Blog)

This creates "parasocial relationships" where people feel like they know you personally, leading to:

Inbound job opportunities
Speaking invitations
Collaboration requests
Consulting offers

Actionable Steps:

Week 1: Set up profiles on 4 platforms
Week 2: Start sharing daily coding tips
Week 3: Write about problems you've solved
Week 4: Engage with other developers' content

2. Climb the Digital Pyramid

Most developers are stuck at the bottom of what I call the Digital Pyramid:

Level 4: Financial Assets (Building businesses that sell)
Level 3: Data & Software (Automated systems)
Level 2: Intellectual Property (Your unique ideas)
Level 1: Skilled Labor (Trading time for money) ← Most devs are here

The Goal: Move up the pyramid by:

Level 1 → 2: Start creating content about your coding expertise
Level 2 → 3: Build tools, libraries, or SaaS products
Level 3 → 4: Package your knowledge into courses, books, or consultancies

3. Master the AI-Developer Collaboration

Instead of competing with AI, learn to amplify your capabilities with it:

Current AI Tools Every Developer Should Know:

GitHub Copilot: Pair programming with AI
ChatGPT/Claude: Code explanation and debugging
Cursor: AI-powered code editor
Replit: AI-assisted development environment

The New Developer Workflow:

Ideation: Use AI to brainstorm solutions
Architecture: Design systems with AI assistance
Implementation: Write code collaboratively with AI
Testing: Generate test cases with AI
Documentation: Create docs with AI help

The Communication Framework That Works

When networking or interviewing, use this structure:

  name: "Your name and current role",
  same: "What industry/category you belong to",
  fame: "What makes you notable (projects, achievements)",
  aim: "What you're working on in the next 90 days",
  game: "Your 3-6 year vision"

Example:

"I'm Sarah, a full-stack developer (name) specializing in React and Node.js applications (same). I recently built a viral productivity app that hit 10K users in its first month (fame). Currently, I'm working on integrating AI features into the app (aim), with the goal of building a suite of AI-powered productivity tools (game)."

The Mindset Shift

From: "I'm a coder who writes software" To: "I'm a problem-solver who uses code and AI to build solutions"

From: "I need to learn every new framework" To: "I need to understand how to leverage AI to solve business problems"

From: "My GitHub commits define my value" To: "My ability to ship products that people want defines my value"

Action Items for This Week

Choose your 4 platforms and create consistent profiles
Start documenting your learning in public (blog posts, videos, tweets)
Experiment with AI coding tools for 30 minutes daily
Identify one problem you can solve with code + AI
Connect with 5 developers who are building in public

The Bottom Line

The traditional path of "learn to code → get hired → climb the corporate ladder" is disappearing.

The new path is "learn to code → build in public → create value → attract opportunities."

Critical thinking and creative problem-solving will be the last skills standing.

But only if you start positioning yourself now.

What's Next?

I'm documenting my entire journey of transitioning from traditional developer to AI-augmented creator. If you want to follow along, connect with me on:

Twitter: [@yourhandle] - Daily insights and experiments
LinkedIn: [Your profile] - Professional updates and networking
GitHub: [Your profile] - Open source AI projects
Newsletter: [Your newsletter] - Weekly deep dives

Question for the community: What's your biggest concern about AI's impact on development careers? How are you preparing for this transition?

Remember: You can't learn to ride a bicycle from a book. The only way forward is to start experimenting and building.

Tags: #AI #SoftwareDevelopment #CareerAdvice #TechCareers #ArtificialIntelligence #Programming #DeveloperLife #TechTrends #FutureOfWork #MachineLearning

Understanding Space and Time Complexity in Software Development

Ifedayo Agboola — Tue, 01 Jul 2025 09:00:00 +0000

In the world of software development, writing code that works is only half the battle. The real challenge lies in writing code that performs efficiently and scales well. This is where understanding space and time complexity becomes essential.

This article aims to explain the core ideas behind these concepts, what they are, why they matter, and how to reason about them using Big O notation.

What Is Time Complexity?

Runtime refers to the actual time it takes for a program or algorithm to complete a task. However, when analyzing algorithms, we are more interested in time complexity, which expresses how the runtime grows in relation to the size of the input.

Time complexity helps us reason about performance regardless of specific hardware or system load. It tells us how well an algorithm will scale and is typically expressed using Big O notation.

Common Types of Time Complexity

Below are the most widely encountered time complexities, each with practical implications in software engineering:

1. Constant Time – O(1)

An algorithm runs in constant time if its execution time remains the same regardless of the input size.

Problem: Given an array of integers, retrieve the first element.

Use Case: Best for operations that don't depend on the size of the input, often seen in hash table lookups and array index access.

// JavaScript
function getFirstItem(arr) {
    return arr[0];  // Always takes the same time
}

// Testing with different array sizes
const smallArray = new Array(100).fill(1);
const largeArray = new Array(1000000).fill(1);

console.time('Small array - O(1)');
getFirstItem(smallArray);
console.timeEnd('Small array - O(1)');
// Small array - O(1): 0.006ms

console.time('Large array - O(1)');
getFirstItem(largeArray);
console.timeEnd('Large array - O(1)');
// Large array - O(1): 0.005ms (virtually the same!)

// C#
public int GetFirstItem(int[] arr)
{
    return arr[0];  // Always takes the same time
}

// Testing in C#
var smallArray = new int[100];
var largeArray = new int[1000000];

var sw = System.Diagnostics.Stopwatch.StartNew();
GetFirstItem(smallArray);
sw.Stop();
Console.WriteLine($"Small array - O(1): {sw.Elapsed.TotalMilliseconds}ms");

sw.Restart();
GetFirstItem(largeArray);
sw.Stop();
Console.WriteLine($"Large array - O(1): {sw.Elapsed.TotalMilliseconds}ms");

2. Linear Time – O(n)

Here, runtime grows proportionally with the input size. If the input doubles, the time taken roughly doubles as well.

Problem: Find the maximum value in an array.

Use Case: Common in straightforward algorithms like searching an unsorted list or basic summations.

// JavaScript
function findMax(arr) {
    let max = arr[0];
    for (let i = 1; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}

// Testing linear time growth
const arr1000 = Array.from({length: 1000}, () => Math.random() * 1000);
const arr10000 = Array.from({length: 10000}, () => Math.random() * 1000);
const arr100000 = Array.from({length: 100000}, () => Math.random() * 1000);

console.time('1,000 elements - O(n)');
findMax(arr1000);
console.timeEnd('1,000 elements - O(n)');
// 1,000 elements - O(n): 0.082ms

console.time('10,000 elements - O(n)');
findMax(arr10000);
console.timeEnd('10,000 elements - O(n)');
// 10,000 elements - O(n): 0.234ms (roughly 10x more)

console.time('100,000 elements - O(n)');
findMax(arr100000);
console.timeEnd('100,000 elements - O(n)');
// 100,000 elements - O(n): 2.156ms (roughly 100x more than 1,000)

3. Quadratic Time – O(n²)

Algorithms with quadratic time complexity involve nested iterations over the input data. As the input grows, performance deteriorates quickly.

Problem: Find all duplicate pairs in an array (naive approach).

Use Case: Common in algorithms like bubble sort or when examining all pairwise combinations.

// JavaScript
function findDuplicatePairs(arr) {
    const pairs = [];
    for (let i = 0; i < arr.length; i++) {
        for (let j = i + 1; j < arr.length; j++) {
            if (arr[i] === arr[j]) {
                pairs.push([i, j]);
            }
        }
    }
    return pairs;
}

// Testing quadratic time growth - notice the dramatic increase!
const arr100 = Array.from({length: 100}, () => Math.floor(Math.random() * 50));
const arr200 = Array.from({length: 200}, () => Math.floor(Math.random() * 100));
const arr400 = Array.from({length: 400}, () => Math.floor(Math.random() * 200));

console.time('100 elements - O(n²)');
findDuplicatePairs(arr100);
console.timeEnd('100 elements - O(n²)');
// 100 elements - O(n²): 0.425ms

console.time('200 elements - O(n²)');
findDuplicatePairs(arr200);
console.timeEnd('200 elements - O(n²)');
// 200 elements - O(n²): 1.634ms (roughly 4x more - quadratic!)

console.time('400 elements - O(n²)');
findDuplicatePairs(arr400);
console.timeEnd('400 elements - O(n²)');
// 400 elements - O(n²): 6.825ms (roughly 16x more than 100 elements!)

4. Logarithmic Time – O(log n)

In logarithmic time, the runtime grows slowly even as the input size increases significantly. These algorithms often reduce the problem size with each step.

Problem: Given a sorted array and a target value, find the index of the target. Return -1 if not found.

Use Case: Ideal for operations that repeatedly divide a problem in half.

// JavaScript
function binarySearch(arr, target) {
    let left = 0;
    let right = arr.length - 1;

    while (left <= right) {
        const mid = Math.floor((left + right) / 2);

        if (arr[mid] === target) return mid;
        if (arr[mid] < target) left = mid + 1;
        else right = mid - 1;
    }

    return -1;
}

// Generate sorted arrays of different sizes
const sorted1000 = Array.from({length: 1000}, (_, i) => i);
const sorted100000 = Array.from({length: 100000}, (_, i) => i);
const sorted10000000 = Array.from({length: 10000000}, (_, i) => i);

console.time('1,000 elements - O(log n)');
binarySearch(sorted1000, 750);
console.timeEnd('1,000 elements - O(log n)');
// 1,000 elements - O(log n): 0.015ms

console.time('100,000 elements - O(log n)');
binarySearch(sorted100000, 75000);
console.timeEnd('100,000 elements - O(log n)');
// 100,000 elements - O(log n): 0.018ms (100x more data, barely any change!)

console.time('10,000,000 elements - O(log n)');
binarySearch(sorted10000000, 7500000);
console.timeEnd('10,000,000 elements - O(log n)');
// 10,000,000 elements - O(log n): 0.021ms (10,000x more data, still fast!)

5. Comparing Different Complexities

Let's see all complexities side by side with the same input size:

// Create a test array
const testArray = Array.from({length: 10000}, (_, i) => i);
const shuffledArray = [...testArray].sort(() => Math.random() - 0.5);

// O(1) - Get first element
console.time('O(1) - Get first');
const first = testArray[0];
console.timeEnd('O(1) - Get first');
// O(1) - Get first: 0.003ms

// O(log n) - Binary search
console.time('O(log n) - Binary search');
binarySearch(testArray, 7500);
console.timeEnd('O(log n) - Binary search');
// O(log n) - Binary search: 0.012ms

// O(n) - Linear search
console.time('O(n) - Linear search');
const found = shuffledArray.find(x => x === 7500);
console.timeEnd('O(n) - Linear search');
// O(n) - Linear search: 0.145ms

// O(n log n) - Sorting
console.time('O(n log n) - Sort');
const sorted = [...shuffledArray].sort((a, b) => a - b);
console.timeEnd('O(n log n) - Sort');
// O(n log n) - Sort: 1.246ms

// O(n²) - Find all pairs (limited to first 100 to avoid long wait)
const smallSlice = testArray.slice(0, 100);
console.time('O(n²) - All pairs (100 elements)');
const pairs = [];
for (let i = 0; i < smallSlice.length; i++) {
    for (let j = i + 1; j < smallSlice.length; j++) {
        pairs.push([smallSlice[i], smallSlice[j]]);
    }
}
console.timeEnd('O(n²) - All pairs (100 elements)');
// O(n²) - All pairs (100 elements): 0.892ms

What Is Space Complexity?

While time complexity measures how long an algorithm takes, space complexity measures how much additional memory it requires as the input grows.

// O(1) Space - Uses a fixed amount of extra space
function sumArray(arr) {
    let sum = 0;  // Only one extra variable regardless of array size
    for (let num of arr) {
        sum += num;
    }
    return sum;
}

// O(n) Space - Creates a new array proportional to input
function doubleArray(arr) {
    const doubled = [];  // New array grows with input
    for (let num of arr) {
        doubled.push(num * 2);
    }
    return doubled;
}

// Measuring memory usage (conceptual - actual measurement is complex in JS)
const bigArray = new Array(1000000).fill(1);
const doubled = doubleArray(bigArray);
console.log('Original array length:', bigArray.length);
console.log('Doubled array length:', doubled.length);  // Same size = O(n) space

Big O Notation Summary

Time Complexity	Notation	Description	Real-world Example
Constant	O(1)	Independent of input size	HashMap lookup, array access
Logarithmic	O(log n)	Halves problem each step	Binary search, balanced trees
Linear	O(n)	Visits each element once	Finding max, counting items
Quadratic	O(n²)	Nested loops over data	Bubble sort, finding all pairs

Visualizing Growth with Actual Timings

// Let's see how different algorithms scale
function measureComplexities(n) {
    const arr = Array.from({length: n}, (_, i) => i);

    console.log(`\n--- Input size: ${n} ---`);

    // O(1)
    console.time('O(1)');
    arr[0];
    console.timeEnd('O(1)');

    // O(log n)
    console.time('O(log n)');
    binarySearch(arr, Math.floor(n * 0.75));
    console.timeEnd('O(log n)');

    // O(n)
    console.time('O(n)');
    arr.reduce((a, b) => a + b, 0);
    console.timeEnd('O(n)');

    // O(n²) - only for smaller inputs
    if (n <= 1000) {
        console.time('O(n²)');
        for (let i = 0; i < arr.length; i++) {
            for (let j = 0; j < arr.length; j++) {
                // Just access elements
                arr[i] + arr[j];
            }
        }
        console.timeEnd('O(n²)');
    }
}

// Test with increasing sizes
measureComplexities(100);
measureComplexities(1000);
measureComplexities(10000);
measureComplexities(100000);

Practical Tips

Don't Optimize Prematurely: Focus on writing clear, correct code first. Use timing measurements to identify actual bottlenecks.
Consider Trade-offs: Sometimes you can trade space for time. Caching results uses more memory but can dramatically reduce computation time.
Know Your Data Structures: Different structures have different complexity characteristics:

* Array access: O(1)

* Array search: O(n)

* HashMap lookup: O(1) average

* Tree operations: O(log n) when balanced

Measure Real Performance: Big O describes growth trends, not actual speed. Always profile your specific use case.

Conclusion

Understanding time and space complexity is crucial for writing efficient, scalable software. By measuring actual performance and recognizing complexity patterns, you can make informed decisions about algorithm choice. Start by timing your code, identify bottlenecks, and apply these concepts to write better, faster programs.

C# Loops: for vs while - When to Use Each (With Real Examples)

Ifedayo Agboola — Thu, 12 Jun 2025 09:00:00 +0000

Stop guessing which loop to use. Here's a simple, real-world guide to choosing between for and while loops in C#.

Stop guessing which loop to use. Here's the simple decision framework.

Ever stared at your code wondering: "Should I use a for loop or while loop here?"

You're not alone. This confusion trips up beginners constantly, and I see experienced developers make the wrong choice too.

Here's the truth: picking the right loop isn't about syntax, it's about intent.

Let me show you exactly when to use each one, with real examples you'll actually encounter.

The Simple Decision Rule

Use for loops when: You know exactly how many times to repeat

Use while loops when: You repeat until some condition changes

That's it. Everything else flows from this.

For Loops: "Do This X Times"

Perfect for countable operations:

Example 1: Processing Arrays

int[] scores = { 95, 87, 92, 78, 88 };

// You know exactly how many elements to process
for (int i = 0; i < scores.Length; i++)
{
    Console.WriteLine($"Student {i + 1}: {scores[i]}%");
}

Example 2: Building Patterns

// Print a 5x5 grid of stars
for (int row = 0; row < 5; row++)
{
    for (int col = 0; col < 5; col++)
    {
        Console.Write("* ");
    }
    Console.WriteLine();
}

Why for works here: You have a clear start (0), clear end (5), and predictable steps.

While Loops: "Do This Until..."

Perfect for dynamic conditions:

Example 1: User Input Validation

string password;
do
{
    Console.Write("Enter password (min 8 characters): ");
    password = Console.ReadLine();
} 
while (password.Length < 8); // Keep asking until valid

Example 2: File Processing

StreamReader reader = new StreamReader("data.txt");
string line;

while ((line = reader.ReadLine()) != null) // Read until end of file
{
    ProcessLine(line);
}

Why while works here: You don't know in advance how many iterations you'll need.

Common Mistakes (And How to Fix Them)

Mistake 1: Using `while` for Simple Counting

// ❌ Awkward and error-prone
int i = 0;
while (i < 10)
{
    Console.WriteLine(i);
    i++; // Easy to forget this!
}

// ✅ Much clearer intent
for (int i = 0; i < 10; i++)
{
    Console.WriteLine(i);
}

Mistake 2: Using `for` for Unknown Iterations

// ❌ Feels forced and unnatural
for (string input = ""; input != "quit"; input = Console.ReadLine())
{
    ProcessCommand(input);
}

// ✅ Expresses intent clearly
string input;
while ((input = Console.ReadLine()) != "quit")
{
    ProcessCommand(input);
}

Real-World Decision Making

Here are scenarios you'll actually face:

Scenario	Best Loop	Why
Process every item in a list	`for`	Known count
Wait for user to enter "quit"	`while`	Unknown duration
Generate 100 random numbers	`for`	Exact count needed
Read lines until file ends	`while`	File size unknown
Display a countdown timer	`for`	Known start/end
Retry failed network requests	`while`	Success unpredictable

Challenge: Put Your Skills to the Test

Here's a practical problem you might encounter in real projects:

Write a function that counts how many times a character appears in a string:

// Example: CountChar("hello world", 'l') should return 3
public static int CountChar(string text, char target)
{
    // Your solution here
}

Try solving this with both loop types. Which feels more natural?

Spoiler alert: Both work, but one will feel obviously better once you try them.

You can also practice similar problems on LeetCode here.

Pro Tips for Loop Mastery

1. Read Your Code Aloud

for: "For each item in this collection..."
while: "While this condition is true..."

The right choice usually sounds more natural.

2. Consider Future Maintenance

// This screams "I'm processing a fixed collection"
for (int i = 0; i < users.Count; i++)
{
    ValidateUser(users[i]);
}

// This says "I'm waiting for something to happen"
while (!connectionEstablished)
{
    TryConnectToServer();
    Thread.Sleep(1000);
}

3. Watch Out for Infinite Loops

// ❌ Infinite loop - forgot to increment
int i = 0;
while (i < 10)
{
    Console.WriteLine(i);
    // Missing: i++;
}

// ✅ For loop prevents this mistake
for (int i = 0; i < 10; i++)
{
    Console.WriteLine(i);
}

The Bottom Line

Stop overthinking it:

Know your iterations in advance? → Use for
Waiting for something to change? → Use while
Processing collections? → Usually for (or foreach)
User input or external conditions? → Usually while

The "right" loop makes your code easier to read, understand, and maintain. Your future self (and teammates) will thank you.

Your turn: Which loop type do you reach for most often? Share your reasoning in the comments!

CSharp #Programming #Loops #CleanCode

Should You Learn C# Instead of Python or JavaScript in 2025?

Ifedayo Agboola — Thu, 05 Jun 2025 10:20:28 +0000

The honest answer might surprise you.

Last week, I told everyone to start with Python or JavaScript. Then my inbox exploded with one question:

"What about C#? Is it still worth learning in 2025?"

Here's my honest take after looking at the current job market, AI tooling, and where the industry is heading.

Spoiler alert: C# might actually be the dark horse winner for 2025.

Why I Originally Recommended Python & JavaScript

Let me be clear—Python and JavaScript are still fantastic choices:

Python:

Super easy to read (looks like English)
Perfect for beginners
Huge in data science and AI
Tons of tutorials everywhere

JavaScript:

Runs websites (literally everywhere)
See results instantly in your browser
Massive job market
Easy to get started

Both languages have massive communities, which means when you get stuck, help is everywhere. Plus, AI tools like ChatGPT have seen millions of Python and JavaScript examples, so they're great at helping beginners.

The bottom line: If you want to build something this weekend and learn coding principles fast, Python and JavaScript are your best friends.

But Here's What Changed My Mind About C

I've been watching the job market closely, and something interesting is happening. C# developers are quietly becoming some of the highest-paid and most in-demand programmers.

Here's why C# is secretly winning in 2025:

Enterprise Companies Love It

Walk into any bank, hospital, or government office. Their core systems? Probably running on C#.

Translation: Stable, high-paying jobs that aren't going anywhere.

AI Tools Actually Love C# Now

GitHub Copilot and ChatGPT work amazingly well with C#. Microsoft has been pouring resources into making AI coding tools work perfectly with their ecosystem.

Translation: Learning C# with AI is actually really smooth now.

Built for Big Projects

C# has something called "strong typing"—basically, it catches your mistakes before your code even runs. This makes it perfect for large, complex applications.

Translation: Your code is less likely to break in weird ways.

Gaming & Beyond

Want to make games? Unity (the biggest game engine) uses C#. Want to build web apps? C# does that too with Blazor. Cloud apps? C# is everywhere on Microsoft Azure.

Translation: One language, many career paths.

The Real Comparison (2025 Edition)

Let me break this down simply:

For Getting Started This Weekend:

Winner: Python or JavaScript
Why: Simpler setup, see results faster

For Getting Hired in 6 Months:

Winner: C# (tied with JavaScript)
Why: Enterprise demand is massive

For AI-Assisted Learning:

Winner: All three are excellent now
Why: AI tools support all of them really well

For Long-Term Career Growth:

Winner: C#
Why: Enterprise systems aren't going anywhere

What This Means for You

Choose Python if:

You want to get into data science or AI
You want the gentlest learning curve
You prefer simple, readable code

Choose JavaScript if:

You want to build websites and web apps
You want to see visual results immediately
You like the idea of front-end development

Choose C# if:

You want high-paying enterprise jobs
You prefer structure and organization
You're interested in games, business apps, or cloud development
You want a language that will stay relevant for decades

The AI Factor Changes Everything

Here's what's really interesting: AI tools have eliminated most of the traditional barriers to learning C#.

Old problem: "C# setup is complicated" 2025 reality: AI can walk you through setup in minutes

Old problem: "C# syntax is harder" 2025 reality: AI explains everything as you code

Old problem: "Fewer beginner tutorials" 2025 reality: AI generates unlimited personalized tutorials

With tools like GitHub Copilot and Visual Studio, learning C# in 2025 feels almost as smooth as learning Python.

My Updated Recommendation

For absolute beginners: Start with Python for 2-3 weeks to learn basic concepts, then switch to C# if you're interested in enterprise work.

For career switchers: Go straight to C# if you want stable, high-paying jobs.

For entrepreneurs/freelancers: JavaScript for web projects, Python for data projects.

The plot twist: You don't have to choose forever. With AI helping you, learning a second language takes weeks, not months.

Getting Started with C# in 2025

If I convinced you to try C#, here's your starter pack:

Tools:

Visual Studio Code (free) or Visual Studio Community (also free)
GitHub Copilot for AI assistance
.NET SDK (Microsoft's free development kit)

First Project Ideas:

A simple calculator
A to-do list that saves to files
A basic web API that returns weather data

Learning Path:

Build a console app (command line program)
Add a simple web interface with Blazor
Connect to a database
Deploy to the cloud

With AI helping every step, this journey takes weeks, not months.

The Bottom Line

Python and JavaScript are still fantastic for beginners. But if you're thinking about your career in 2025 and beyond, C# deserves serious consideration.

The combination of:

High enterprise demand
Excellent AI tooling support
Microsoft's massive investment
Strong typing for better code quality

...makes C# one of the smartest languages to learn right now.

My advice? Pick the language that excites you most. With AI as your coding partner, you'll learn faster than you ever thought possible—regardless of which language you choose.

My Learning Journey (And Why You Should Join Me)

Before you go, let me be honest about something: I'm learning C# myself right now.

Instead of waiting until I'm an "expert" to share knowledge, I'm documenting everything as I go—the struggles, breakthroughs, and those magical "aha!" moments that happen when you learn to code with AI as your partner.

Here's what I'm building:

Every week, I publish new articles about C# and AI-assisted programming. We're starting with the absolute basics and gradually building up to advanced topics. Think of it as learning together rather than being taught from some distant ivory tower.

What you can expect if you follow along:

Real beginner struggles (and how AI helps solve them)
Weekly C# tutorials that build on each other
Honest reviews of AI coding tools
Career tips from someone actually making the transition
Projects that go from "Hello World" to enterprise-level applications

I believe the best way to learn is alongside someone who's just a few steps ahead of you. That's exactly what I'm offering.

Ready to join the journey?

We're all figuring this out together. Let's make 2025 the year we master C# and AI-assisted development.

Which language are you leaning toward? And what C# topic should I tackle next? Drop your thoughts below—I read every single comment!

[Boost]

Ifedayo Agboola — Mon, 02 Jun 2025 09:19:09 +0000

Ifedayo Agboola

May 30 '25

Learning to Code in the AI Era: Your 2025 Survival Guide

#ai #beginners #programming #githubcopilot

Comments

4 min read

Learning to Code in the AI Era: Your 2025 Survival Guide

Ifedayo Agboola — Fri, 30 May 2025 16:00:00 +0000

Stop memorizing syntax. Start building stuff.

Remember when learning to code meant memorizing hundreds of functions and wrestling with confusing error messages for hours? Those days are over.

AI coding assistants like GitHub Copilot and ChatGPT have completely changed the game. But here's the plot twist: you still need to learn how to code. You just need to learn it differently.

Think of it this way: instead of becoming a human compiler, you're becoming a conductor. The AI orchestra can play the notes, but you decide the music.

The New Coding Reality

Old way: Spend 6 months learning syntax before building anything useful.

New way: Start building on day one, learn concepts as you need them.

Here's what actually matters now:

1. Talk to Your Code Like a Human

Code isn't just instructions for computers anymore—it's a conversation. When you sit down to code, start by writing what you want in plain English:

// I want to build a simple to-do app that:
// - Adds new tasks
// - Marks tasks as complete  
// - Saves everything locally

Then ask your AI assistant to help you build it. That simple description becomes your roadmap.

2. Learn the Big Ideas Fast

You still need to understand:

Variables (boxes that hold stuff)
Loops (doing things repeatedly)
Functions (reusable chunks of code)
Data structures (ways to organize information)

But here's the magic: ask AI to explain these concepts at exactly your level.

Try this: "Explain loops like I'm 10 years old, then show me 3 real examples."

The AI will give you perfect explanations and examples instantly. No more boring textbooks!

3. Start With Python or JavaScript

Pick one of these two. Why?

Python: Great for beginners, used everywhere
JavaScript: Runs websites, lots of jobs available

Both have huge communities and work amazingly well with AI tools.

4. Build Tiny Projects, Not Todo Lists

Forget the classic "build a calculator" tutorials. Make stuff you actually want:

Week 1: A script that texts you the weather every morning Week 2: A simple website that shows your favorite quotes

Week 3: A tool that organizes your photos by date

Each project teaches you something new, but you're building real things you'll actually use.

Your AI Coding Workflow

Here's how a typical coding session works now:

Step 1: Describe What You Want

"I want to make a website that shows random cat facts when you click a button."

Step 2: Let AI Scaffold

The AI gives you a basic structure. Don't worry if you don't understand everything yet.

Step 3: Ask Questions

"Why did you use this function?" "What does this line do?" "How can I make it look better?"

Step 4: Test and Improve

Run your code. When something breaks (it will!), paste the error into your AI assistant and ask for help.

Pro Tips for AI-Assisted Learning

Write Better Prompts

Instead of: "Make a website" Try: "Create a simple HTML page with a button that shows random jokes from an API when clicked. Use vanilla JavaScript, no frameworks."

Always Ask "Why"

When AI gives you code, don't just copy it. Ask:

"Why did you choose this approach?"
"Are there simpler ways to do this?"
"What could go wrong with this code?"

Build Quality Habits Early

Save your code with Git (version control)
Write simple tests
Ask AI to review your code for problems

Your Weekly Learning Plan

Monday-Tuesday: Pick one concept (like loops) and understand it deeply

Ask AI for explanations and examples
Build a tiny project using just that concept

Wednesday-Thursday: Build something slightly bigger

Combine this week's concept with previous learning
Let AI help with the setup and debugging

Friday: Polish and test

Ask AI to suggest improvements
Write simple tests to make sure it works

Weekend: Share what you built

Post on social media or a blog
Explain what you learned in your own words

Total time needed: 6-8 hours per week. That's it!

Essential Tools for 2025

For writing code:

VS Code with GitHub Copilot
Cursor (AI-first code editor)
Replit (code in your browser)

For learning:

ChatGPT or Claude for explanations
YouTube for visual learning
GitHub for saving your projects

For practice:

Build small projects daily
Contribute to open source (AI makes this much easier)
Join coding communities on Discord or Reddit

The Bottom Line

Learning to code in 2025 isn't about becoming a walking documentation site. It's about:

Understanding problems clearly
Communicating with AI effectively
Judging solutions critically
Building real things quickly

The AI handles the syntax headaches. You focus on the creative problem-solving that makes coding fun.

Start today. Pick a tiny project you actually want. Ask an AI assistant to help you build it. You'll be shocked how quickly you start creating real software.

Remember: You're not trying to outsmart the AI. You're learning to dance with it.

Ready to start? Open ChatGPT or GitHub Copilot right now and ask: "Help me build a simple [thing you want to make]." Then just... start building.

The future of coding is collaborative. Welcome to the team.

[Boost]

Ifedayo Agboola — Thu, 22 May 2025 09:19:47 +0000

Ifedayo Agboola

May 21 '25

Can You Spot These 5 Common C# Data Type Mistakes?

#programming #csharp #dotnet #beginners

Comments 4

3 min read

DEV Community: Ifedayo Agboola

Fixing the “Module not found: Can't resolve '@/…'” Error in Next.js (and Why It Happens on Netlify)

Why It Happens

1. Your local environment is forgiving — Netlify’s isn’t.

2. Your alias (@) isn’t configured for the build

The Fix

Step 1 — Add paths to tsconfig.json

Step 2 — Add a Webpack alias in next.config.mjs

Step 3 — Match file and import casing

Step 4 — Clear cache and redeploy

Bonus — If you see this with Supabase

Quick Summary

Lessons Learned

Final Thoughts

How To Build Your Own Cloud

Roadmap (today & next)

LESSON 1: Hardware (pick what fits your budget)

The decision tree (plain English)

Minimum specs for this course

Quality-of-life add-ons (optional)

LESSON 2 — Ubuntu Server (Install & first boot)

2.1 Create install media

2.2 BIOS/UEFI boot

2.3 The installer (what to pick & why)

2.4 First login (locally or over SSH)

2.5 Update the system (security baseline)

LESSON 3 — Secure Access (SSH keys, firewall, updates)

3.1 Generate an SSH key (on your laptop)

3.2 Copy your key to the server

3.3 Test key login

3.4 Enable & configure the firewall (UFW)

3.5 Harden SSH (disable password & root logins)

3.6 Automatic security updates

Bonus safety nets (optional but nice)

“What can go wrong?” (real mistakes we’ve made)

Recap (what you achieved today)

Your First AI Agent: A Clear, Practical Path

Why agent projects stall

The 8-Step Path (with mini checklists)

1) Pick one very small, very clear job

2) Choose a base LLM (don’t train anything yet)

3) Decide how it touches the outside world (the part most people skip)

4) Build the skeleton workflow (before any frameworks)

5) Add memory carefully (later, and only if needed)

6) Wrap it in a simple interface

7) Iterate in tiny cycles

8) Keep scope under control

Minimal code skeletons

A. Python (requests + your tools)

B. TypeScript (Node) shape you can grow

Prompts that keep agents honest

A few good first agents to build

Pitfalls & guardrails

What this buys you

PS: Attribution

Originality, Creativity, Visibility: The Three Multipliers of Modern Success

Why skills alone don't compound and what does.

Why These Three And Why Now

1) Originality: Stop Consuming, Start Connecting

2) Creativity: Build Something, Anything

3) Visibility: Show Up Where People Already Are

How They Work Together

Your 30 Day Start

What Trips People Up

Start Small, Start Now

Beyond Coding: How to Survive and Thrive in the AI Revolution

The Developer's Guide to Surviving the AI Revolution

The Wake-Up Call

The Uncomfortable Truth About Coding

This Isn't Your Typical Tech Revolution

The Real Questions We Need to Ask

1. Can we slow down AI development?

2. Can we coexist with AI?

The Skills Gap Crisis

The Developer's Survival Strategy

1. Build Your Technical Brand

2. Climb the Digital Pyramid

3. Master the AI-Developer Collaboration

The Communication Framework That Works

The Mindset Shift

2. Your alias (`@`) isn’t configured for the build

Step 1 — Add paths to `tsconfig.json`

Step 2 — Add a Webpack alias in `next.config.mjs`

Mistake 1: Using `while` for Simple Counting

Mistake 2: Using `for` for Unknown Iterations