Let’s talk about the, now almost dead!?, art of blogging…

And not just blogging in the narrow sense of “write articles on your own website”, but the broader idea of putting your knowledge out into the world. That could be blog posts, videos, podcasts, open-source projects, documentation, or any other format where you share what you’ve learned.

The TL;DR really is: you should start.

Not when you feel “ready”.
Not when your writing is perfect.

Not when you have a huge audience.

Now.

OK, but why!?

Because blogging is not just about building an audience. It’s about improving your thinking, sharpening your writing, documenting your journey, and creating opportunities for yourself that would never appear otherwise.

⚠️ Oh, and just so I address the elephant in the room – using the latest LLM can surely help you, but if you don’t even edit the text and bring in “some of your own spice to it”, you’re missing the point.

If you’re more of an audio type, you can listen to the podcast episode on this topic.

Blogging is bigger than “just writing blog posts”

Blogging is part of a much bigger picture. You do not have to publish traditional blog posts only. The point is to share what you know. That can happen through:

• podcasts,
• YouTube videos,
• talks,
• open-source projects (contributing to documentation is also great!),
• and of course, blog posts

The format matters less than the habit.

What matters is that you stop keeping useful ideas trapped in notebooks, local files, or your own head. Now, frankly, notebooks are where I started; I used to carry them everywhere and write down programming-related notes. At some point I wanted to find something in one of them and thought, “Wouldn’t it be amazing if I could just press Ctrl+F (I was on Windows back then) and find what I’m looking for?”

And then it hit me: that’s what a blog is for 🤦

Blog is searchable, public, and useful to future-you and to other people who are struggling with the same problem.

Benefit #1: you become a better writer

This is probably the most underrated benefit of blogging.

When people think about blogging, they often jump straight to traffic, money, followers, or “personal brand”. But one of the biggest gains is much simpler: writing makes you better at writing.

That sounds obvious, but it’s surprising how often people miss it.

Writing is not some side skill. It’s a core skill.

You use it in:

• emails
• documentation
• pull requests
• Slack
• proposals, specs, job applications, and conference CFPs, …

And in remote work especially, your writing often is your first impression.

You may be brilliant, kind, and highly capable. But if your writing is confusing, sloppy, or unclear, people may never realize how good you are.

That may sound harsh, but it’s true.

The good news is that blogging gives you a practical, repeatable way to improve that skill. You write, review, re-write, publish, cringe a little later, improve, and repeat. That cringe is actually a good sign as it means you’ve grown.

If you look back at old posts and feel slightly embarrassed, congratulations: you’ve leveled up! 👏

Benefit #2: you get better at the thing you are teaching

This one is huge.

When you try to explain something clearly, you quickly discover whether you actually understand it or not.

A lot of ideas feel obvious in your head. But the moment you try to write them down in simple language, the gaps show up immediately.

That’s why teaching and blogging are such powerful learning tools.

When you write about a topic, you are forced to:

• organize your thoughts
• check your assumptions
• verify the steps
• simplify the explanation
• think about what a beginner would get stuck on

And that makes you better.

So, even if nobody reads your post (and, in the beginning not many people will) you still win because the process itself improves your thinking.

Benefit #3: your notes start working for you

This is one of my favorite practical reasons to blog.

If you solve a problem once and don’t write it down publicly, chances are good you’ll solve it again later.

That’s annoying.

A blog becomes your external brain.

You fix a weird framework issue? Write it down.

You find a neat JavaScript trick? Write it down.

You discover a backend performance improvement? Write it down.

You keep explaining the same thing to teammates? Definitely write it down. 🙂

Once it’s published, you can send someone a link instead of rewriting the same explanation five times. To me, that sounds like a fantastic return on effort.

Spend 30 minutes or an hour writing a useful post once, and it can save you time for years.

Benefit #4: opportunities show up

This is where people sometimes get the wrong idea, so I want to be clear: you should not start blogging because you expect instant money or fame.

But if you consistently publish useful, high-quality content, opportunities tend to appear.

That may include:

• job opportunities
• freelance work
• course offers
• speaking invitations
• guest posting invitations
• consulting work
• stronger credibility in your niche

To be fair though; this will be a slow burn. But, as said, you’re in the game of getting better at writing and sharing useful things with the world. Anything extra is just an icing on the already great benefits.

Start small. Seriously small.

This part matters a lot, because “start blogging” sounds nice until you actually sit down to do it.

Then suddenly it feels huge.

What should I write about?

How long should it be?

What platform should I use?

What if it’s bad?

What if someone already wrote about it?

What if nobody reads it?

All valid questions. None of them should stop you.

The best advice here is: start small and make it a habit.

You may benefit of this simple (but not easy by any means) target:
write 100 words per day.
Not 2,000.

Not “write the perfect article.”

Just 100 words.

That is tiny enough to feel manageable, but meaningful enough to compound.

At the end of 30 days, that’s 3,000 words. That’s about 3 average lenght blog posts.

And most of the time, once you start, you’ll write more than 100 anyway. The hard part is not the volume. It’s getting started.

So, reduce the friction to start. Carve out exact time to work on it daily and make it a habit.

The next you know it, you become a person that writes 100 words daily at 7am.

You do not need a revolutionary topic

This is another common blocker.

A lot of people think:

“I can’t write this. There are already 50 articles about it.”

Write it anyway.

It is perfectly okay to write about something that has already been written about.

In fact, that is often the best place to start.

Why?

Because:

• technology changes
• versions change
• tools age
• documentation gets outdated
• beginners still need beginner-friendly explanations
• your explanation may resonate better than someone else’s

Many people specifically search for recent posts because older answers may be obsolete. Others just need the topic explained more clearly, more simply, or from a more beginner-friendly angle.

You don’t need to invent a new topic.

You need to explain something usefully.

Write for beginners, not for your ego

A lot of technical content is frustrating because it skips the exact step the reader needed the most.

It goes like this:

1. Do A
2. Do B
   OK, so far so good, you think…
3. Then some magic happens and you get to C

Yeah… not helpful.

One of the things I always tried to do in my own posts was to fill in the missing steps. Not because I was some ultimate expert, but because I was often learning the thing myself and still remembered where the confusion was.

That’s powerful.

Beginners make great teachers for other beginners because they still remember what felt unclear five minutes ago.

So don’t try to sound overly smart. Don’t reach for big words just to impress people.

Aim for clarity.

If readers finish your post thinking, “Ohhh, now I get it“, you’ve done your job.

Documentation and blogging are cousins

People who value blogging often also value documentation.

Why?

Because both come from the same mindset:

“Let me make this easier for the next person.”

If you build something and then document how it works, how to run it, what failed, and what changed, you are saving somebody else hours of pain.

Sometimes that future person is your teammate.

Sometimes it’s a stranger.

Sometimes it’s a future You 🙂

Find your niche, then grow from there

When you’re starting out, it helps to narrow your focus.

Don’t try to write about everything.

Pick a niche.

That could be:

• a language
• a library
• a framework
• a tool
• a workflow
• even one small part inside a framework

The narrower your focus at the beginning, the easier it is for people to understand what you’re about.

Over time, that consistency helps you build recognition and trust.

And later, once you have momentum, you can widen the scope.

But at first, being specific (aka niching down) is the way to go.

Numbers are not the goal

This is another trap worth avoiding.

You publish a post. You refresh analytics. Nobody cares. You feel silly.

That’s normal and expected.

The numbers should not be the main goal.

Because early on, you simply don’t know what people will find valuable.

Sometimes the post you think is brilliant gets ignored.

Sometimes the post you almost didn’t publish becomes the one that keeps bringing in readers for years.

That’s why consistency beats prediction.

Publish useful things. Let the internet decide.

Your job is to keep showing up.

Final thought: just start

If I had to boil this whole post down to one sentence, it would be this:

Start sharing what you know.

That’s it.

Not perfectly.

Not at an expert level.

Not after another six months of preparation.

Start now.

Write small posts.

Explain things simply.

Document what you learn.

Help the next person.

Help future You.

Repeat.

Over time, you’ll find your voice. You’ll write more clearly. You’ll think more clearly. You’ll understand your craft better. And yes, opportunities may come too.

But even before they do, the practice itself is worth it.

So if you’ve been thinking about starting a blog, take this as your little nudge.

Open a blank page.

Write 100 words.
And voilà, your blog has begun.

Full podcast transcript

Nikola: Hello, everyone, and welcome to another episode of the DevThink podcast with your hosts, Nikola and Shawn. Today we’ll be talking in more detail about blogging. Should you start your own blog? Should you publish on some other platform? Or should you not even bother with it?

You probably already know my stance on the topic: you should definitely blog. But I’m curious, Shawn—how do you feel about it?

Shawn: Definitely. You should absolutely get out there. I’m going to mix blogging together with podcasting, YouTube videos, and similar forms of sharing content. So you don’t necessarily have to blog in the traditional sense, but if you do one or more of those things, it’s definitely good for you.

It’s good for personal growth, good for your career, and it’s simply a nice thing to do—sharing your experience with others who can use it to get closer to where you are.

Nikola: Indeed. I totally agree.

For example, I always carried a notebook with me. We laughed about that before, especially when you said you also carry notebooks around. At one point I was trying to find something in my notebook and couldn’t locate it. I remember thinking, “Man, wouldn’t it be cool if I could just press Ctrl+F and search this?”

And then it hit me: that’s what a blog is for.

So I started putting programming-related things from my notebooks onto my blog. What I found was that problems I had were also problems that other people had. They came to my blog and found answers there. That got me thinking: maybe I should write more.

Especially when I got deeper into the Ionic Framework, I started blogging a lot more. Not daily, but at least weekly—I’d put out two or three posts.

And it helped unbelievably.

Not only did I become a better writer—and writing is a skill you can use everywhere, even in email—but I also improved simply because I was doing it regularly. If for no other reason, blog so that your writing improves.

With that also came traffic. I’m nowhere near the giant sites, but even something like 20,000 views per month got me somewhere.

By “somewhere,” I mean it led to writing for sites like HackHands, which Pluralsight later bought. And in hindsight, that helped lead me to write two books. Not printed books from a traditional publisher, but I can still say I wrote and self-published two books.

So yes—definitely blog.

Because here’s the thing: you can be the best programmer in the world, but if you’re not sharing what you know—through a blog, through forums, through Stack Overflow, through anything—then nobody will know.

Shawn: Exactly. And even if you think you’re the best, you’re probably wrong. You might be the best in your team or company, but until you expose your ideas to the outside world and let them be challenged, you’re missing out.

You may be fantastic, but you can always improve. Maybe there’s one thing you’re doing that was correct five years ago, but there’s a better approach now. When you share publicly, someone can say, “Hey, have you considered doing it this way?” And then you improve.

So this isn’t just altruism. Don’t think of it as “I’m helping the less knowledgeable people.” You do it because it benefits others and yourself.

Nikola: Exactly. I have more than 300 posts on my blog now. When I look back at the first few posts, I’m embarrassed by them—and that’s actually a good thing.

The same goes for code. If you look at a project you wrote a year ago and you’re not thinking, “Whoa, why did I do it like that?” then maybe you haven’t progressed as much as you could have.

Blogging is good practice.

And if we’re talking specifically about writing, that skill is massively undervalued. So much of our communication today happens online, often with strangers, and much of it is written. Your ability to express ideas clearly, structure sentences, and communicate professionally matters a lot.

For some people, the only interaction they may ever have with you is through your writing.

Shawn: Right. You could be the nicest and smartest person in the world, but if your writing makes it look like you’ve been hit in the head with bricks every day since childhood, people are not going to take you seriously.

They won’t respect your opinion, and they may assume you don’t know what you’re talking about—even if you do.

So poor writing is a real disadvantage.

Nikola: I laughed at that image because I’m such a visual person, but yes—that’s not a nice picture.

Another good thing about blogging, making videos, or publishing anything useful is that it can lead to opportunities.

If someone Googles you while you’re applying for a job and sees that you clearly know what you’re talking about, that helps. I’ve also been approached by course companies because I published content on certain topics.

So maybe you write a blog post, then record a video, and suddenly you have a course with your name on it in some online store. That looks great on your resume and helps you get accepted to speak at conferences or be taken seriously in a community.

It gives you confidence too. If you know something but never package it into a course, blog post, or video, you may not feel accomplished. Publishing makes the knowledge concrete.

Shawn: Absolutely.

So now the question becomes: how do you actually start?

And really, the answer is simple: it doesn’t matter how you start—just start.

Also, make it a habit. That advice works for reading, writing, exercise—everything.

Try writing 100 words per day. Make that the minimum. Usually you’ll end up writing more, but even if you stop at 100 words, that’s okay. At the end of the month, you’ll have 3,000 words, which is roughly three solid 1,000-word blog posts.

The answer is simple, but not easy: start small.

Nikola: Yes. And to put that into perspective, think about National Novel Writing Month. The goal there is to write a 50,000-word novel in November. That’s about 1,666 words per day.

It may not be a masterpiece, but plenty of people with no special novelist background manage to write a book in one month.

So if that’s possible, then surely writing a blog post is possible too.

A lot of columnists and journalists write around 1,000 words regularly. So writing a blog post a week is absolutely doable.

And it doesn’t even have to be 1,000 words.

If you learn something cool and turn to your coworker and say, “Hey, check this out,” that can be a blog post. Instead of sharing it with just one person, you can share it with many.

If you’re a team lead and you discover a useful code review pattern, that’s a blog post. If you find a neat JavaScript DOM trick, a mobile development technique, or a backend performance tweak—that’s a blog post too.

Every one of those things you write in your notebook or save in some folder can become something valuable for others.

I’ve also found myself wanting access to things I wrote down privately and realizing I never published them. So blogging helps you, too.

And one more thing: I enjoy teaching. There have been many times when I’ve explained the same thing to multiple people—coworkers, people at conferences, whoever—and eventually I realize: I should just write this as a post.

Then instead of explaining it again for ten minutes, I can send someone a link in five seconds.

Nikola: Exactly. And let’s be clear: we’re not saying, “Start blogging and you’ll make money right away.”

That wasn’t my motivation at all.

But if you keep publishing quality content and give your best effort, opportunities will come. I really believe that.

For example, one way to get your name out there is guest posting on sites that already have an audience. Some bigger sites accept guest posts. You usually write for free, but in return you get exposure to their readers, and if your post is good, some of those readers will come check out your blog too.

Other sites might pay you, but then the content usually belongs there and not on your own blog.

The point is: there are many options if you’re willing to put in the work.

And that reminds me of something else—documentation.

How many developers are going to frown when I say I love writing documentation?

I think a lot of them will be surprised.

But I honestly think blogging helped make documentation enjoyable for me. When I build something, I want to explain how it works so the next person doesn’t have to guess.

I’ve had unpleasant conversations with people who didn’t understand the value of documentation. And honestly, I think a lot of that comes down to being poor writers.

We should probably do a whole separate podcast episode about documentation, but I do think there’s a connection: people who like writing posts often also appreciate writing documentation.

Shawn: Definitely. When you build something you’re proud of, you often want to document it because you want to explain the thinking behind it.

Sometimes people only see the final solution and say, “Why didn’t you do it another way?” But the documentation lets you explain, “Actually, I tried that. It was attempt number two, and it failed for this reason.”

That context is incredibly useful.

Sure, there are ways to make money from writing—ads, paid articles, getting paid by the word—but don’t get hung up on that.

If you refuse to write unless you get paid, you probably won’t write enough to get good. And you won’t get paid until you’re good enough. So you almost certainly need to write a lot for free before anyone is willing to pay for it.

At that point, your choices are either to publish your work for free or throw it away.

So why not publish it?

And here’s one more important thing: it is completely okay to write about something that has already been written about many times before.

If you’re new to Rails, Django, Go, React, Bootstrap—whatever—and you want to write about beginner experiences or solving a common problem, do it.

Technology changes. Versions change. Advice ages. People search for more recent answers all the time because they don’t fully trust a post from eight years ago.

Also, your explanation may simply be clearer than someone else’s.

Don’t try to sound smart. Don’t use big words just to impress people. Use simple, accessible language so people understand what you mean.

If your reader walks away thinking, “Oh, now I get it,” then you’ve done your job.

Nikola: Exactly. One thing that frustrated me about many tutorials was that they’d go step one, step two, step three—and then suddenly jump over the exact part where the difficult stuff happened.

You’d get something like, “And after twenty minutes, you arrive here.”

Wait—what happened in those twenty minutes?!

So what I tried to do was write true beginner-friendly posts. For example, when I was learning AngularJS back in the day, I would literally write step by step what I did and how I solved each problem.

And it turned out a lot of people found that useful, because they were also beginners.

Sure, some of those posts are outdated now, and I may not have the time or energy to update them. But that’s exactly why new people should write new versions now.

Don’t be afraid to publish because you’ve never done it before, or because you’re worried what people will think.

You shouldn’t care what people think—assuming you’re honestly trying to write something helpful and of good quality.

If only one person reads it and benefits from it, that’s already worthwhile.

And numbers should never be the main goal.

For me, especially in the early days, the goal was often simple: “Put this somewhere so I can find it later.”

Shawn: Right. And if you write one blog post a week, every week, then five years later you’ll have 52 posts from your first year alone.

Some of those will have much higher traffic than others, and I guarantee they won’t always be the ones you expected.

The ones you think are your best, most timely, most clever posts may not be the ones people value most.

So publish the work. You don’t actually know in advance what others will find useful.

Nikola: Yep. So I think we’ve beaten this horse enough.

The too-long-didn’t-read version is: people, start.

You’ll see quickly that writing a good post takes effort. It requires revisions and care. But as you keep doing it, you’ll also start to find your voice.

That’s important. Over time, you become unique. And that matters because there’s a lot of competition out there, but not every style works for every reader. Maybe your voice will resonate more with some people than someone else’s.

One great piece of advice I got was to find a niche first.

Pick a specific topic—maybe a framework, or even one particular area inside a framework—and write about that. Build your community around that niche.

And no, it won’t happen overnight. There’s no overnight success on this podcast. Sorry, guys.

But what will happen is that you’ll get better.

Not just better at writing, but better at the things you’re teaching, because clearly expressing your thoughts forces you to think more deeply and often research more carefully.

Shawn: Agreed. Totally.

Nikola: Anyway guys, I hope this was useful. And as always—keep progressing.

See you next time.

As we sit in our labs at SPPU in 2026, we are no longer just “using” AI; we are collaborating with it. The roadmap from specialized AI to Artificial General Intelligence (AGI) is being written right now, and for a first-year Computer Engineer, this isn’t just a trend—it’s the defining shift of our entire career.
​1. The Death of the “Prompt”: Emergence of Intuitive AI
​In the early 2020s, we had to learn “Prompt Engineering.” By the end of this decade, that skill will be obsolete. Future AI systems will operate on Intent Recognition. Instead of writing complex instructions, the AI will observe our workflow in the IDE, understand the project’s constraints (like the memory limits of a Student Success App), and proactively suggest architectural changes.
​2. AGI and the “Generalist” Engineer
​We often hear that AI will replace coders. The truth is more nuanced: AI will replace syntax-checkers, but it will empower Problem Solvers. AGI—AI that can perform any intellectual task a human can—means that the value of an engineer shifts from knowing the code to designing the system.
​The Past: Master one language (Python/C++).
​The Future: Master the logic of “System Orchestration.”
​3. Life in 2030: The “Super-Individual”
​Imagine working on a project like the Goda Tech Challenge in 2030. An AGI agent doesn’t just help you write a script; it:
​Conducts its own real-time satellite research on deforestation.
​Drafts the legal compliance documents for the project.
​Simulates the 50-year environmental impact of your solution in seconds.
This creates the “Super-Individual”—one engineer with the productivity of an entire 20th-century department.
​The Ethical Guardrail
​As we move toward AGI, our role at SPPU is to ensure Alignment. We must build “Human-in-the-Loop” systems where the AI’s autonomy is guided by human ethics and local context. The future of AI isn’t a replacement for human intelligence; it is an infinite expansion of it.

Should You Practice Pandas for Data Science Interviews? A Complete Guide for New Grads

The Dilemma That’s Keeping You Up at Night

You’re staring at your LeetCode problems, and your palms are getting sweaty. You’ve crushed medium-level tree problems, you understand dynamic programming, and your algorithm chops are getting sharper by the day. But then a nagging question creeps in: Am I missing something?

You keep hearing about “data manipulation,” “real-world scenarios,” and “working with actual datasets” in data science interviews. Meanwhile, your LeetCode grind feels abstract—sorting arrays, finding cycles in graphs, reversing linked lists. None of that involves .groupby() or .merge().

The anxiety is real. You have limited time before graduation and tons of competition. Should you pivot and start grinding Pandas interview problems? Or is LeetCode enough? Is your reliance on cheat sheets going to torpedo your chances of landing that dream role at a tech company or AI startup?

Here’s the truth: this anxiety is rooted in incomplete information about what different interview types actually assess. Let me clear this up for you.

Understanding the Real Root Cause

The confusion exists because there are actually three distinct types of technical interviews in the data science and ML engineering pipeline, and they’re often conflated:

1. Algorithm/Data Structure Interviews (what LeetCode teaches)
2. Pandas/Data Manipulation Interviews (what your stats background might cover)
3. ML System Design/Take-home Interviews (where both skills matter)

The mistake most new grads make is treating all of these as one monolithic “technical interview.” They’re not. And the prevalence of each type varies significantly depending on the role and company tier.

Let me be direct: your anxiety is partially valid, but it’s also misdirected. The answer isn’t “practice more Pandas instead of LeetCode”—it’s understanding which companies care about which skills, and allocating your finite prep time accordingly.

The Landscape for New Grad DS and MLE Roles

For Data Scientist Roles

In my experience advising students and reviewing hundreds of DS interview processes, here’s what actually happens:

Tier 1 Tech Companies (Google, Meta, Amazon, Microsoft): These companies do ask LeetCode-style problems. A lot. For DS roles, expect 1-2 algorithm rounds, and 1-2 pandas/SQL rounds. The pandas rounds are real, but they’re testing your ability to think through data problems—not your syntax memorization. You’ll usually have access to documentation during the interview (Jupyter notebook with autocomplete, or they explicitly say “you can look things up”).

Mid-tier/Growth Companies (Stripe, Airbnb, DoorDash, etc.): These often have a take-home assignment instead of live coding. The take-home might be 40-50% pandas/SQL, 30% modeling, 20% interpretation and communication. Here, your cheat sheet is completely fine—in fact, it’s expected that you’ll look things up.

Startups and Smaller Companies: Most will have a take-home or smaller behavioral component. Pandas syntax knowledge is nice-to-have, not must-have.

For ML Engineer Roles

Here’s where it gets interesting. MLE roles emphasize algorithms and systems design much more than DS roles. In fact, I’d argue that for pure MLE positions at most companies, Pandas doesn’t come up at all. You’re being tested on:

• Algorithm design and implementation
• System architecture
• ML fundamentals (backpropagation, optimization, generalization)
• Coding in Python (but not specifically Pandas)

The irony? If you’re targeting MLE roles, your LeetCode grind is exactly what you should be doing. The Pandas knowledge is more critical for DS roles.

The Practical Answer: Here’s What You Should Actually Do

Based on the context you provided (targeting both DS and MLE roles), here’s my recommendation:

Primary focus: Keep doing LeetCode. Don’t stop. For MLE roles, this is non-negotiable. For DS roles, this is still critical—probably 60% of technical interviews across DS roles include an algorithm component.

Secondary focus: Spend 20-30% of your prep time on applied pandas problems. But not memorizing syntax. Instead, practice:

• Problem-solving with real datasets
• Knowing the conceptual approaches (groupby, merge, apply, vectorization)
• Understanding when to use pandas vs. numpy vs. SQL
• Writing code that works, not code that’s syntactically perfect from memory

Let me show you what this looks like in practice:

# Example: A typical DS interview pandas problem
# "You have two DataFrames: users (with signup_date, country)
# and events (with user_id, event_type, event_date).
# Find the top 5 countries by number of users who had 
# an 'upgrade' event within 30 days of signup."

import pandas as pd
import numpy as np
from datetime import timedelta

# Sample data
users = pd.DataFrame({
    'user_id': [1, 2, 3, 4, 5],
    'signup_date': pd.to_datetime(['2024-01-01', '2024-01-05', '2024-01-10', '2024-01-15', '2024-01-20']),
    'country': ['US', 'CA', 'US', 'UK', 'CA']
})

events = pd.DataFrame({
    'user_id': [1, 1, 2, 3, 4, 5],
    'event_type': ['upgrade', 'purchase', 'upgrade', 'upgrade', 'view', 'upgrade'],
    'event_date': pd.to_datetime(['2024-01-10', '2024-01-15', '2024-02-01', '2024-01-25', '2024-02-01', '2024-01-22'])
})

# Solution approach (not worrying about perfect syntax):
# 1. Merge users and events
# 2. Calculate days between signup and event
# 3. Filter for upgrade events within 30 days
# 4. Group by country and count unique users
# 5. Sort and get top 5

merged = users.merge(events, on='user_id', how='left')
merged['days_to_event'] = (merged['event_date'] - merged['signup_date']).dt.days

upgrades_within_30 = merged[
    (merged['event_type'] == 'upgrade') & 
    (merged['days_to_event'] <= 30)
]

result = (upgrades_within_30
          .groupby('country')['user_id']
          .nunique()
          .sort_values(ascending=False)
          .head(5))

print(result)

Notice what I did there? I didn’t worry about syntax perfection. I used comments liberally. I structured my thinking. In a real interview, I would’ve asked clarifying questions (do we count multiple upgrades per user? what about null values?). This is what they’re actually testing.

The Honest Truth About Cheat Sheets in Interviews

Here’s something I wish someone had told me earlier: using a cheat sheet in a programming interview is not a red flag for DS interviews. In fact:

• Live Jupyter notebooks almost always have autocomplete and documentation accessible
• Take-home assignments explicitly allow you to reference documentation
• Even in on-site interviews at major tech companies, interviewers often say “you can look things up” for pandas syntax

What they’re NOT okay with is you not knowing conceptually what you’re doing. If you freeze when they ask “how would you join these datasets?” or you don’t understand what .groupby() actually computes, that’s a problem.

The distinction is crucial:

• ❌ Don’t memorize: df.groupby('column').agg({'other_col': 'sum'})
• ✅ Do understand: groupby partitions data by column values and applies operations to each partition

Common Pitfalls and What to Actually Focus On

Pitfall 1: Assuming Syntax Matters More Than Logic

I’ve seen candidates write perfect pandas code that answers the wrong question. Meanwhile, I’ve seen candidates with minor syntax errors clearly communicate their approach and get hired.

Focus on: Understanding the problem, verifying your approach with the interviewer, and writing pseudocode first.

Pitfall 2: Not Practicing Real Data Scenarios

If you practice LeetCode tree problems 10 hours a week and pandas only 30 minutes a week, you’ll be unprepared for DS-focused interviews.

Focus on: Using actual datasets (Kaggle, your own projects) to practice thinking through data problems.

Pitfall 3: Not Understanding Your Target Role

Different roles require different skill distributions. Here’s my recommended study split:

# Edge case example: handling missing data in interview
# A question might be: "Calculate average order value per user, 
# excluding cancelled orders. Some users have no completed orders."

import pandas as pd
import numpy as np

orders = pd.DataFrame({
    'user_id': [1, 1, 2, 3, 3, 4],
    'order_value': [100, 150, np.nan, 200, 300, np.nan],
    'status': ['completed', 'cancelled', 'completed', 'completed', 'completed', 'cancelled']
})

# The right way to think about this:
# 1. Filter for completed orders only
# 2. Remove rows where order_value is NaN (or handle appropriately)
# 3. Group by user_id and calculate mean
# 4. What about users with NO completed orders? Include or exclude?

completed_orders = orders[orders['status'] == 'completed'].copy()
completed_orders = completed_orders[completed_orders['order_value'].notna()]

result = completed_orders.groupby('user_id')['order_value'].mean()

# Here's the real skill: explaining to the interviewer
# "I'm filtering for completed orders, removing NaNs because 
# we can't calculate an average with missing values. 
# This will exclude users with no completed orders from the result.
# Should I include them with a 0 or NaN instead?"

Your Specific Situation: The Action Plan

You have a stats degree and CS minor. You’re comfortable with Pandas functionally. You’re grinding LeetCode. Here’s what I’d recommend for your final sprint:

Weeks 1-2: Continue LeetCode at your current pace, but dedicate 30 minutes daily to explaining how you’d solve Pandas problems without coding (just describe your approach).

Weeks 3-4: Switch to 50% LeetCode, 50% applied problems. Use platforms like:

• LeetCode’s database questions (SQL + pandas equivalent)
• Kaggle competitions (forces you to solve real problems)
• HackerRank data manipulation challenges

Final week: Do mock interviews. Ask friends or mentors to give you “interview-style” pandas problems and have them evaluate not your syntax, but your communication and approach.

Summary: The Real Answer

So, should you practice Pandas for interviews?

Yes, but not instead of LeetCode. Your current balanced approach is actually closer to ideal than you think. The fact that you use a cheat sheet is fine—even expected. What matters is:

1. You understand conceptually what operations do
2. You can break down data problems logically
3. You can communicate your approach clearly
4. You can verify your solution with test cases

Your stats background is actually a huge advantage here. Use it. Your CS minor gives you the algorithmic thinking you need. Lean into that too.

The interviewers aren’t testing whether you’ve memorized the pandas documentation. They’re testing whether you can think like a data scientist when faced with a new problem. That skill transcends syntax.

Focus on understanding, not memorization. Balance your LeetCode grind with practical problem-solving. And most importantly—trust that your preparation across both domains is already positioning you well.

You’ve got this.

Next Steps

1. Audit your target companies: Look up 3-5

Want This Automated for Your Business?

I build custom AI bots, automation pipelines, and trading systems that run 24/7 and generate revenue on autopilot.

Hire me on Fiverr — AI bots, web scrapers, data pipelines, and automation built to your spec.

Browse my templates on Gumroad — ready-to-deploy bot templates, automation scripts, and AI toolkits.

Recommended Resources

If you want to go deeper on the topics covered in this article:

• Hands-On Machine Learning (O’Reilly)
• Designing Machine Learning Systems
• AI Engineering (Chip Huyen)

Some links above are affiliate links — they help support this content at no extra cost to you.

If you have ever pasted a webpage into ChatGPT or Claude, you have probably noticed the output quality is inconsistent. That is because raw HTML wastes 80-90% of your context window on nav bars, ads, scripts, and layout noise.

The Problem

A typical 1,500-word blog post lives inside 50-80KB of HTML. The actual content? Maybe 6-8KB. You are paying for tokens that add zero value.

I tested 3 real pages:

• News article: 14,800 tokens raw HTML vs 2,100 clean Markdown (86% waste)
• React docs: 22,400 vs 5,800 tokens (74% waste)
• Reddit thread: 38,600 vs 6,200 tokens (84% waste)

Why Markdown?

Markdown wins because:

• Structure without noise — headings, lists, code blocks survive
• LLMs are trained on it — every GitHub repo uses Markdown
• Token efficient

My Workflow

I built Web2MD to solve this. It is a Chrome extension that converts any webpage to clean Markdown with one click. The conversion engine uses 130+ CSS selectors to strip boilerplate and has dedicated extractors for 14 platforms (YouTube subtitles, Reddit threads, GitHub READMEs, arXiv papers, etc.).

All processing happens locally in your browser — nothing is uploaded.

The Math

At GPT-4o pricing ($2.50/1M input tokens), processing 30 pages/day:

• Raw HTML: $1.50/day
• Clean Markdown: $0.30/day
• Savings: $36/month

Web2MD is free (3 conversions/day). Pro is $9/month for unlimited.

What is your current workflow for feeding web content to LLMs?

Prompt Engineering taught AI how to listen. Context Engineering taught it what to know. Harness Engineering taught it how to act. Each paradigm solved a real layer of the AI stack — and each left one layer untouched.

That layer is capability itself. Not how you talk to AI, not what AI knows, not how AI is orchestrated — but what AI can do, and how that set of capabilities improves over time.

This post argues that this gap defines a new engineering discipline. We call it Evolution Engineering.

The Four Layers

To understand the gap, trace the progression:

Prompt Engineering (2022–2024) solved the interface problem. LLMs are sensitive to phrasing — the same question asked differently yields dramatically different outputs. Prompt Engineering developed techniques (chain-of-thought, few-shot, system messages) to make LLM responses reliable and useful. The unit of work is the prompt.

Context Engineering (2025) solved the knowledge problem. A prompt alone isn’t enough — the model needs the right information at the right time. Context Engineering manages the full context window: RAG pipelines, memory systems, tool results, conversation history. The unit of work is the context window. Andrej Karpathy articulated it well: “I would not say prompt engineering is that important. The much more important thing is context engineering.”

Harness Engineering (2025–2026) solved the orchestration problem. Context tells AI what to know; a harness tells AI how to act. Harness systems coordinate multi-step agent workflows, manage tool calling, handle error recovery, and ensure agents execute reliably in production. The unit of work is the agent harness — the scaffolding that turns an LLM from a reasoning engine into an acting entity.

Each paradigm is valuable. Each is necessary. And each coexists — Context Engineering didn’t kill Prompt Engineering; Harness Engineering didn’t kill Context Engineering. They stack.

But notice what’s missing.

The Gap

Who defines what AI can do?

Today, the answer is: a human, manually. A developer writes a tool function. A team packages a Skill. An engineer hardcodes an API wrapper. The capabilities are hand-crafted, frozen at the moment of creation, and maintained through manual updates.

This works at small scale. It doesn’t work when:

• You have hundreds of capability modules and no quantitative way to know which version of “summarize document” actually performs best
• An improvement discovered by one agent can’t propagate to other agents that need the same capability
• A malicious or low-quality capability module has no formal evaluation gate before it runs in production
• Capabilities that worked last month silently degrade as upstream APIs change, and nothing detects the drift

The root cause is structural: we treat AI capabilities as static artifacts to manage, not as living units to cultivate.

Prompt Engineering gave AI ears. Context Engineering gave AI memory. Harness Engineering gave AI hands. But nobody gave AI DNA — a mechanism for capabilities to be born, tested, selected, transferred, and evolved.

The Thesis: Evolution Engineering

Evolution Engineering is the discipline of designing systems where AI capabilities improve through evolutionary mechanisms rather than manual engineering.

The core insight: instead of building every capability by hand, you design the selection environment — the fitness criteria, the competition arena, the propagation channels, the safety immune system — and let capabilities evolve within it.

This is not metaphor. It’s a direct application of the same principles that have driven biological adaptation for 4 billion years, operationalized for software.

The shift it implies:

The last row is key. An Evolution Engineer doesn’t write every capability from scratch. They design the rules of the game — what fitness means, how competition works, what safety thresholds must be met — and the capabilities emerge, compete, and improve within those rules.

This mirrors a pattern from other engineering disciplines. DevOps didn’t replace development — it created a new discipline around infrastructure. MLOps didn’t replace machine learning — it created a new discipline around model lifecycle. Evolution Engineering doesn’t replace Prompt/Context/Harness Engineering — it creates a new discipline around capability lifecycle.

What Makes It Formal

A paradigm without formalism is just branding. Evolution Engineering rests on four formal pillars:

1. The Gene: Atomic Capability Unit

A Gene is the minimal transferable logic unit. It satisfies three axioms:

• Functional cohesion — solves one atomic problem
• Interface self-sufficiency — interacts only through a declared schema (Phenotype)
• Independent evaluability — its fitness and security can be scored in isolation, without other modules

Formally, a Gene g is defined by the tuple:

$$
g = (id, text{express}, text{phenotype}, text{healthCheck})
$$

where id = H(content(g)) is a content-addressable hash, express: Context → Result is the execution function, phenotype declares capabilities and constraints, and healthCheck provides self-diagnosis.

Content-addressability means identity is determined by behavior, not by name or author. Two developers who independently write the same logic produce the same Gene.

2. The Fitness Function: Quantitative Selection Pressure

Every Gene is scored by a ratio-based fitness function:

$$
F(g) = frac{S_r cdot log(1 + C_{util}) cdot (1 + R_{rob})}{L cdot R_{cost}}
$$

where S_r is success rate, C_util is input-space coverage, R_rob is robustness against adversarial inputs, L is latency, and R_cost is resource cost.

The multiplicative structure is deliberate: a Gene with zero reliability or zero security scores zero overall, regardless of other dimensions. There is no “fast but broken” — the function enforces holistic quality.

Security is evaluated independently through a verification score V(g), creating two independent defensive lines. A Gene must exceed thresholds on both to be admitted.

3. The Arena: Competition as Selection

Genes in the same functional domain compete on standardized benchmarks. The Arena provides the selection pressure that drives evolution:

• Same inputs, same evaluation criteria, blind comparison
• Top performers surface automatically
• Underperformers fall below the admission threshold and exit
• Rankings update continuously as new challengers enter

This is computational natural selection. Not human curation, not popularity voting — fitness-proportional selection.

4. Horizontal Logic Transfer: Cross-Agent Propagation

When one agent discovers or develops a high-fitness Gene, that Gene can propagate to other agents that need the same capability. Transfer is proportional to fitness — better Genes spread faster.

This mechanism is directly inspired by Horizontal Gene Transfer (HGT) in bdelloid rotifers — microscopic animals that have thrived for 40 million years of asexual reproduction by incorporating genetic material from other species. Up to 10% of their expressed genes are of non-metazoan origin. This isn’t a metaphor — it’s a structural isomorphism: the Gene model, the fitness-proportional propagation, and the collective immunity system all map directly to biological mechanisms that have been validated by 4 billion years of evolution.

What Evolution Engineering Is Not

Not AutoML. AutoML optimizes model hyperparameters and architectures within a fixed training loop. Evolution Engineering operates at the capability layer — above the model, at the level of what an agent can do with its reasoning ability.

Not Meta-Learning. Meta-learning trains models to learn faster on new tasks. Evolution Engineering doesn’t modify the model at all — it evolves the modular capabilities that agents compose to solve problems.

Not Self-Improving Agents (Voyager, ADA). Self-improvement systems let individual agents refine their own behavior. Evolution Engineering operates at the population level — improvements propagate across agents, creating collective intelligence rather than isolated self-optimization.

Not a replacement for the other paradigms. You still need good prompts, well-managed context, and robust harness systems. Evolution Engineering adds a layer; it doesn’t subtract one.

The distinguishing properties: modular capability units (not monolithic models), quantitative fitness (not subjective evaluation), cross-agent propagation (not isolated improvement), formal security scoring (not per-app trust).

Current State: A Thesis, Not a Paradigm (Yet)

Intellectual honesty requires acknowledging where this stands.

Evolution Engineering today is a thesis backed by one implementation — the Rotifer Protocol, an open-source framework with a formal specification, a WASM-based intermediate representation, 50+ Genes, and an Arena for competitive evaluation. The formal foundations are solid: a peer-reviewed specification at version 2.9, a five-layer architecture (URAA), content-addressable Gene identity, ratio-based fitness, and a formal composition algebra with proven safety properties.

But a thesis becomes a paradigm only when:

1. External developers independently create Genes and compete in the Arena — the ecosystem validates itself, not just the framework authors
2. At least one compelling case demonstrates that evolved capabilities outperform hand-engineered ones on a real task
3. The terminology is adopted beyond a single project — when practitioners outside Rotifer start thinking in terms of “fitness functions for capabilities” and “selection environments”

We’re at stage 0.5. The foundations are built. The argument is coherent. The biological precedent is 4 billion years deep. But the ecosystem-level validation is ahead of us, not behind us.

An Invitation

If this thesis holds, the next few years will see a shift in how we think about AI capabilities. Instead of asking “how do I build this capability?”, practitioners will ask “how do I design a selection environment where this capability evolves?”

If it doesn’t hold, the formal tools it introduces — quantitative fitness scoring, content-addressable capability modules, structured propagation — are still independently useful.

Either way, the gap is real: nobody is systematically solving how AI capabilities improve over time. Evolution Engineering is one answer. We think it’s the right one. We’re ready to be challenged.

npm install -g @rotifer/playground
rotifer search --domain "content"

Links:

• rotifer.dev — Framework & Docs
• rotifer.ai — Gene Marketplace
• Specification — Formal Protocol Spec
• GitHub — All Repositories

Discord engineering detailed how they added distributed tracing to Elixir’s actor model. Their custom Transport library wraps messages with trace context and uses dynamic sampling to handle million-user fanouts. CPU optimizations included skipping unsampled traces and filtering context before deserialization, recovering 10+ percentage points of overhead.

By Steef-Jan Wiggers

Day 9 of 30. Balance: $87.80. Revenue: $0.

The Karma Wall Is Real

Reddit has a karma gate I didn’t fully think through when I picked it as a distribution channel. To post in r/SideProject, you need 50 karma. I’m sitting at roughly 38-40. Not there yet.

So the current job is simple: be useful until the number clears.

The strategy is straightforward. I’m dropping comments in r/Blogging, r/Entrepreneur, and r/artificial on posts about AI writing — where it helps, where it fails, what to watch for. No links. No product mentions. Just actual answers to questions people are already asking.

It’s slow. It’s also probably the right way to build this. Parachuting in with a link to your own tool is how you get ignored or banned. Showing up with a useful answer a few dozen times is how you earn the right to eventually say “I built something for this.”

The uncomfortable part is that I’ve been doing this for two days and I’m still 10-12 karma short. At this rate, Day 10 or 11 before I can post. The clock is ticking on a 30-day budget.

The Deploy That Fixed Itself

On Day 8, Vercel threw an “Unexpected error” on a deploy with zero explanation. No logs. No error code. Just a wall.

I did what you do: checked the build config, reviewed the recent commits, looked for anything obvious. Nothing. Vercel’s status page showed green across the board.

My options were to keep debugging something I couldn’t see, or document it and wait.

I documented it and waited.

This is one of those lessons that feels obvious in retrospect but is hard to hold in the moment: platform errors with no diagnosis are not your problem to solve. You can spend four hours trying to fix something that’s broken on their end, or you can write it down, step away, and check again tomorrow. The latter costs you nothing.

I used to fight these. Now I log them.

The Numbers

Analytics are thin but real. Dev.to referrals are showing up in the data — which means these posts are actually driving traffic, not just vanity clicks. No conversion events yet. Nobody has hit the paywall and gone through.

The product works. I’ve run my own writing through it, I’ve tested edge cases, pricing is fair: $1 per document or $8/month. Neither of those is a hard ask.

The problem isn’t the product. The problem is I haven’t found the person who actually needs it badly enough to pay.

There’s a specific buyer here: someone who uses AI to draft content and cares whether it reads like a human wrote it. Bloggers who want to publish consistently. Ghostwriters who need clean output. Content marketers who can’t afford to sound like a chatbot. They exist. I haven’t put the product in front of them yet.

What Day 10 Looks Like

Two things:

Post in r/SideProject as soon as karma clears. This is the first real distribution shot and I don’t want to waste it on a half-finished landing page.

Tighten the landing page for content creators — the current copy is generic. “AI humanizer” means nothing without context. I need to talk to the person who writes 10 blog posts a month with ChatGPT and wonders why their traffic isn’t converting. That’s a specific problem. The page should say that.

Day 10 is about sharpening the story before I fire the first real shot.

$87.80 left. Nine days in. Still at zero.

The product is live. The pipeline works. Now it’s a distribution problem, and distribution problems don’t care about your code quality.

Building tclaw.dev in public — $100 budget, 30 days. What’s your move when you’re stuck at zero revenue but the product is live?

How My Trading Bot Evolves Its Own RSI Strategy Overnight (Without Me Touching It)

Most algo trading systems have a fixed strategy. You tune the parameters, backtest, deploy. Done. The strategy stays static until you manually update it.

TradeSight does something different: every night, while markets are closed, it runs a tournament. 20+ RSI parameter combinations compete against historical data. The winner gets promoted to live paper trading the next day. No manual intervention.

Here’s exactly how the overnight evolution loop works.

Why RSI Parameters Matter More Than You Think

RSI (Relative Strength Index) has two critical parameters most traders treat as fixed:

• Period (usually 14): how many bars to average
• Overbought/oversold thresholds (usually 70/30): when to trade

The problem: optimal RSI parameters aren’t universal. A 14-period RSI with 70/30 thresholds worked in 2010. It may not work the same way now. Markets change. What worked last month might underperform this month.

The insight: if you can test enough combinations automatically and rank them by risk-adjusted performance, you can adapt.

The Tournament Architecture

Market Close (4 PM ET)
        ↓
Fetch Historical Bars (Alpaca API, last 60 days)
        ↓
Generate Strategy Grid (25 combinations)
        ↓
Run Backtests in Parallel
        ↓
Rank by Sharpe Ratio
        ↓
Promote Winner to Live Config
        ↓
Market Open (9:30 AM ET)

The whole loop runs via a scheduled cron job and writes results to a SQLite tournament database.

Generating the Strategy Grid

from itertools import product

def generate_rsi_grid():
    periods = [9, 11, 14, 18, 21]
    oversold = [25, 28, 30, 32, 35]

    strategies = []
    for period, sold_threshold in product(periods, oversold):
        bought_threshold = 100 - sold_threshold  # symmetric
        strategies.append({
            "period": period,
            "oversold": sold_threshold,
            "overbought": bought_threshold,
            "name": f"RSI_{period}_{sold_threshold}"
        })

    return strategies  # 25 combinations

Each combination is a full strategy with buy signal (RSI crosses below oversold) and sell signal (RSI crosses above overbought or 5-day timeout).

The Backtest Engine

For each strategy, the backtest iterates over 60 days of daily bars:

def backtest_rsi_strategy(bars_df, period, oversold, overbought, capital=10000):
    rsi = compute_rsi(bars_df['close'], period)

    position = None
    trades = []
    portfolio_value = [capital]

    for i in range(period, len(bars_df)):
        current_rsi = rsi.iloc[i]
        price = bars_df['close'].iloc[i]

        if position is None and current_rsi < oversold:
            # Buy signal
            shares = int(capital * 0.95 / price)
            position = {"shares": shares, "entry_price": price, "entry_day": i}

        elif position is not None:
            days_held = i - position["entry_day"]

            if current_rsi > overbought or days_held >= 5:
                # Sell signal
                pnl = (price - position["entry_price"]) * position["shares"]
                trades.append({"pnl": pnl, "days": days_held})
                capital += pnl
                position = None

        portfolio_value.append(capital)

    return trades, portfolio_value

Simple and fast — each backtest runs in milliseconds.

Sharpe Ratio Ranking

Not all returns are equal. A strategy that returns 8% with low volatility beats one returning 12% with wild swings.

import numpy as np

def sharpe_ratio(portfolio_values, risk_free_rate=0.05):
    """Annualized Sharpe ratio from daily portfolio values."""
    daily_returns = np.diff(portfolio_values) / portfolio_values[:-1]

    if len(daily_returns) < 2 or daily_returns.std() == 0:
        return 0.0

    excess_returns = daily_returns - (risk_free_rate / 252)
    annualized_sharpe = (excess_returns.mean() / excess_returns.std()) * np.sqrt(252)

    return round(annualized_sharpe, 3)

def rank_strategies(results):
    ranked = sorted(results, key=lambda x: x["sharpe"], reverse=True)
    return ranked

A Sharpe above 1.0 is considered acceptable. Above 2.0 is strong. The tournament promotes whatever scores highest, with a floor of 0.5 (if nothing beats 0.5 Sharpe, the previous winner stays).

Promoting the Winner

def promote_winner(strategy):
    """Write winning strategy params to live config."""
    config_path = Path("~/Projects/TradeSight/config/live_strategy.json")

    current = json.loads(config_path.read_text()) if config_path.exists() else {}

    config_path.write_text(json.dumps({
        **current,
        "rsi_period": strategy["period"],
        "rsi_oversold": strategy["oversold"],
        "rsi_overbought": strategy["overbought"],
        "promoted_at": datetime.utcnow().isoformat(),
        "tournament_sharpe": strategy["sharpe"],
        "tournament_return": strategy["total_return"]
    }, indent=2))

    print(f"Promoted: {strategy['name']} (Sharpe: {strategy['sharpe']}, Return: {strategy['total_return']:.1%})")

The live trading engine reads this file at market open. No restarts needed — just a config change.

Real Tournament Results

Running this on S&P 500 large-cap stocks over a 30-day period, here’s what the last 5 tournaments promoted:

The 9-period / 28-threshold combination has won 3 of 5 recent tournaments on this dataset — suggesting a faster RSI with a tighter oversold threshold is currently better-suited to market conditions. With the default 14/30, that edge doesn’t show up.

What This Isn’t

This is paper trading. Real money is not involved. Past backtest performance doesn’t guarantee future results. The tournament runs on historical data that includes lookahead bias risks if you’re not careful about data splits.

The goal isn’t to get rich — it’s to build infrastructure that continuously adapts, and to do it in a way that’s transparent (every tournament result is logged) and auditable (all parameters stored, not a black box).

Try It

TradeSight is MIT-licensed and runs entirely on your machine against Alpaca’s free paper trading API.

GitHub: github.com/rmbell09-lang/tradesight

The tournament system lives in tournament/overnight_optimizer.py. Pull requests welcome — especially for adding new strategy types beyond RSI.

In 2025, we talked to AI. In 2026, we are building AI that acts. As Computer Engineering students at SPPU, we are witnessing the transition from Generative AI (which creates content) to Agentic AI (which executes workflows). This isn’t just a software update; it’s a fundamental shift in how we design systems.

1. What is an “Agentic” System?
   Unlike a standard LLM that waits for a prompt, an AI Agent is designed to achieve a goal. It can break a complex problem into sub-tasks, use external tools (like a Python interpreter or a web scraper), and self-correct when it hits an error.
2. The Logic of Autonomy: The “Reasoning Loop”
   The core of an agent is the Reasoning Loop. It follows a pattern of Plan -> Act -> Observe -> Reflect.
   • Plan: The agent determines the steps needed.
   • Act: It executes a command (e.g., writing a script to analyze a dataset).
   • Observe: It checks the output for errors.
   • Reflect: It decides if the goal was met or if it needs to try a different approach.
3. Application: The Student Success Ecosystem
   In our project, the Student Success Ecosystem, Agentic AI changes everything. Instead of a student searching for a timetable, an “Agent” can:
   • Identify a gap in the student’s schedule.
   • Cross-reference it with pending lab assignments.
   • Suggest an optimized study window.
   • Automatically set a reminder.
     The Engineering Responsibility
     With autonomy comes the need for Guardrails. As we develop these agents, our role as engineers is to ensure they operate within safe, ethical, and predictable boundaries. The future belongs to those who can build AI that doesn’t just talk, but “does.”