feat(blog): add new blog content and self-host existing posts

package.json

@@ -1,7 +1,14 @@
 {
   "name": "elmarchavez",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "private": true,
+  "description": "A professional and modern web portfolio to showcase my projects, skills, and growth as a full stack developer.",
+  "author": "Elmar Chavez",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CodingWithJiro/elmarchavez.git"
+  },
   "scripts": {
     "dev": "next dev",
     "build": "next build",
@@ -51,4 +58,4 @@
     "typescript": "^5",
     "vitest": "^4.1.5"
   }
-}
+}

src/app/blog/[slug]/page.tsx

@@ -74,11 +74,11 @@ export default async function ArticlePage({ params }: ArticlePageProps) {
     >
       <ArticleHeader breadcrumbItems={breadcrumbItems} blogMeta={blog} />
 
-      <article className="prose prose-img:mx-auto mb-4 max-w-none">
+      <article className="prose prose-img:mx-auto mb-8 max-w-none">
         <Article />
       </article>
 
-      <div className="flex items-center justify-between">
+      <div className="before:border-border relative flex items-center justify-between pt-8 before:absolute before:top-0 before:left-1/2 before:w-1/4 before:-translate-x-1/2 before:border-t">
         <Link
           href="/"
           className="focus-visible:outline-muted-foreground flex items-center gap-1 rounded-sm text-[0.85rem] font-normal underline-offset-4 outline-2 outline-offset-6 outline-transparent hover:underline focus-visible:transition-colors focus-visible:duration-150 focus-visible:ease-in-out md:text-[0.875rem]"

src/content/blog/blog-5.mdx

@@ -0,0 +1,141 @@
+Over the past couple of months, I've read a lot of articles about the consequences of AI dependency and one prominent finding is **cognitive atrophy**. In other words, it's about suffering from gradual skill decay because of over-reliance on AI.
+
+Most of the realizations involve **not solving the problem directly**. Software engineers instinctively ask AI what to do first instead of thinking of a solution themselves. This means skipping the crucial process of **thinking**. This is primarily why I chose the banner above: _The Blind Leading the Blind (1568)_ by _Pieter Bruegel the Elder_.
+
+It depicts a row of blind men being led by also a blind man until they eventually stumble and fall. The artwork painted centuries ago still mirrors what's happening in today's world. The only difference is, _we are deliberately making ourselves blind_
+
+---
+
+## Prompt > Accept > Repeat
+
+Notice there's no review step. That's the problem. You may think this workflow is fine. You may say _"It's just a small change, nothing to be worried about really"_, until you repeat the process over and over again and these **"small changes"** eventually accumulate. Stretch it out over the long term and you'll slowly realize you can't **"code"** anymore without AI.
+
+> We are intentionally not looking at the generated code anymore.
+
+![Monkey looking away.](/img/monkey-looking-away.webp)
+
+AI-generated code is clean and deceiving at the same time. The UI looks good and the test (which it also generated) passes. It's like everything in the codebase is made out of rainbows and sunshine. No wonder engineers are just accepting changes and then moving on. _But we are more than that._
+
+Skill decay isn't unique to this industry. Any skill not used regularly will eventually deteriorate. It's always easier to _dictate_ what to do until you _do the task yourself_. Oftentimes, dictating something isn't the same as actually implementing the task.
+
+Executing the task yourself forces your brain to think. You'll find the right edge cases. You'll think more about the UX. You'll think about which tests make sense. You'll find which code matters more. That's the beauty of doing it yourself and using AI as a complement for repetitive tasks. It's a completely different story when we outsource all of the thinking to AI.
+
+Sure you could argue that human-written code isn't perfect. The majority of us are not _gifted programmers_. Our code often has _human errors_. But that's the main reason why it's already valuable.
+
+> There is a human attached to it.
+
+Someone already owns the decision. Someone is already accountable. Someone already has the context. When there's a mistake, that someone already has the foundation and they are not starting from zero. They built the code in the first place, they could fix it too. Struggling, making wrong assumptions, and eventually finding the right solution are the crucial steps for making genuine understanding. The next time they'll encounter the same problem, they have a pretty good chance of solving it alone this time resulting in better efficiency.
+
+Use AI to learn and let it intentionally expose your gaps. Question and scrutinize it. Challenge and verify it at the same time. That's a much healthier way of using AI without surrendering the thinking process itself. But if you are going to delegate all the work to it, you might as well declare yourself as a _tab-pressing robot_ for AI.
+
+---
+
+## Blind Trust Creates A Domino Effect
+
+When unreviewed AI generated code is pushed for a PR review, the domino starts to fall. The junior trusts the AI, the senior trusts the junior, and eventually the code reaches production. This doesn't only cause cognitive atrophy, it also creates a false sense of trust.
+
+![Domino effect for accepting AI generated code.](/img/domino-effect-meme.webp)
+
+> How did we allow ourselves to get to this point?
+
+Speed was never the best measure of quality code. A codebase is fragile. It always was. One wrong implementation can cause a multitude of errors.
+
+AI lays down perfectly convincing code. The author sees it and gets trapped in the illusion that it works without actually understanding it. Context is already lost the moment this new code is pushed. You are betting on it to work from the start instead of deliberately increasing the chances for success by _actually looking at it_.
+
+Instead of the senior asking whether this is a good change, they might first wonder whether the junior actually understands what they sent (or if they even read the code at all).
+
+> Who even likes reading 1000+ lines of slop?
+
+Reading AI-generated code is _contagious_ to the point that the reviewer might as well be lazy too and accept the changes without reviewing them.
+
+It is human nature after all. If too much change is introduced at once, quality checking isn't uniformly implemented. It tempts the reviewer to skip through the entire change, skim the important parts, or worse, rely on AI review agents on top of it. This adds even more uncertainty.
+
+AI is good but only when used as a _complement_, not as a _substitute_. It is a tool to be used correctly and responsibly. You can't force everyone to use this workflow, but you can always start with yourself. Read before sending, understand the PR, push with intention.
+
+The point is to make your PR _"ready for review"_. It doesn't have to be perfect. The most important thing is that _it is yours_, and you can defend it in a snap when the reviewer asks about it. You can explain the ins and outs of your code and ultimately answer the question _"Why?"_.
+
+The next step would be another set of eyes to look over your code, add some polish, some minor (or major) fixes, or request additional refactoring. Discussing about the changes is what causes the context to be _naturally transferred_ to team members.
+
+If done right, people would eventually follow. If not, at least you've saved yourself from **cognitive atrophy**.
+
+---
+
+## The Human Mind Needs To Be Challenged
+
+To combat cognitive atrophy, we must find ways to challenge our minds. The data suggests that the current workflow isn't enough. We need to exercise our brains.
+
+Personally, what I do is always solve at least one coding challenge every day, record myself doing it, and explain my thought process step by step as if I were teaching someone how to solve it. Below is my current collection of videos just talking to the camera and showing my screen.
+
+![Code challenges folder.](/img/code-challenges.webp)
+
+It exposes my gaps, and I like that. Whenever I review my recordings, I could easily take note of the parts where I am struggling and parts where I find myself pausing during an explanation. Mistakes and pauses always ground me to the reality of my current skill level. But the best thing about this setup is that it gives me something tangible to improve upon while keeping my brain active and allowing it to form new connections.
+
+> I have seen clear improvements.
+
+When I compare my very first recording to how I explain things now, I can tell that I am sharper and I now have a deeper understanding of the language and concepts I'm working with. It gives me a real comparison and personally I prefer it that way. Just like in video games, I always get motivated to grind more when I see my character's stats improve over time.
+
+Beyond coding challenges, I also make sure to scrutinize my work by double checking best practices and methods. I find it useful to first search the internet for documentation, examples, and different approaches. After forming my _own ideas_, I then use AI to complement that knowledge and help me understand the subject on a deeper level.
+
+> There are also times when I caught AI suggesting deprecated methods.
+
+This is something I wouldn't have noticed if I hadn't done my own due diligence of studying the subject beforehand. And what was AI's answer after I called it out?
+
+**"You're absolutely right!"**
+
+Yeah... that's when I realized how _unreliable_ AI is.
+
+It's a hit or miss. You're much more likely to miss something if you have little to no knowledge of the subject to start. I mean, they themselves are already telling us before we type our prompts.
+
+![ChatGPT label that says it can make mistakes.](/img/chatgpt-can-make-mistakes.webp)
+
+But overall, these are some of my activities that work for me and they may be different for you. What's important is you are constantly challenging your mind just enough to keep it sharp.
+
+Cognitive atrophy creeps in the moment you decide to outsource your thinking. You'll only realize it when you find yourself _struggling to code the way you used to without the help of AI_.
+
+---
+
+## Discipline is the Ultimate Form of Self-Respect
+
+Yes, I will not be a hypocrite and tell everyone that I never tried using AI-generated code once. I did, and I did not like it. I opened my localhost and was greeted by multiple bugs. The bugs themselves weren't the ones that frustrated me. _The mere fact that I don't know where to look is the problem._
+
+> The feeling of helplessness and the lack of ownership was overpowering.
+
+I didn't create the code, AI did. So I continued and tried prompting again. It gave me around three to five pre-check actions that I need to verify first to solve the problem. _It was exhausting._ That workflow was not for me. When the bug was still not fixed, it gave me another list of pre-checks and possible fixes essentially generating another solution again and again.
+
+![AI generated code loop diagram.](/img/ai-generated-code-loop.webp)
+
+You could argue that I don't have the experience yet and I don't have the correct prompt, or that I don't have the correct markdown files for describing the architecture and additional context. That's fair.
+
+But if we're willing to go that far to have an AI code that **"works"**, then we might as well do the code ourselves.
+
+> Fine, I'll do it myself. So I did.
+
+It took me around 15-30 mins to debug, reiterate, study, fix, break, fix again and then create the component I needed. There were struggles, but they were the kind of struggles where I knew I was getting somewhere. The experience was like physically climbing a ladder. The struggle is tangible.
+
+And more importantly, I knew more than I did before. My code was my own. My mistakes were my own. My solutions were my own. Finally, the understanding I gained was something that sticks.
+
+> My only enemy in this setup is my discipline.
+
+I once read a quote about discipline: _"Discipline is the ultimate form of self-respect"_. It stuck with me the moment I read it and I think it perfectly applies here.
+
+In a world where generating code is easier every day, having the discipline to learn without cutting corners is a _superpower_. Fundamentals are always present in every endeavor we find ourselves in. Investing in them through proper discipline implicitly earns your self-respect and eventually the respect from the engineers around you.
+
+---
+
+## Open Your Eyes
+
+The solution is simple.
+
+To combat cognitive atrophy, we should think for ourselves more. The more we exercise our minds, the more we can preserve the skills we've worked so hard to build.
+
+**I'm not saying we should abandon AI altogether**. That would be a waste of an available resource. What I'm saying is to use AI responsibly. Use it as a tool and a complement that can elevate our thinking even further, _not replace it_.
+
+AI is powerful but not to the point that it should take over every single decision involved in building software. That would be a ticket straight to cognitive atrophy. Remember, AI amplifies both the positive and the negative practices of the engineer controlling it. Like any other tool, if used improperly, the output will eventually go sideways.
+
+At the end of the day, become part of a new generation of software engineers that still values quality. It doesn't have to be perfect and delivered fast. What's important is that you own it, you can defend it, you can fix it when something goes wrong, and ultimately, you are constantly improving in your own right. _Don't let convenience become the reason to outsource your thinking._
+
+> So open your eyes.
+
+![Cyclops opening his eyes for a full red laser attack in Avengers: Doomsday](/img/cyclops-open-your-eyes.webp)
+
+_Thank you for reading. This was longer than I expected. I decided to add this epic image from Avengers: Doomsday trailer last minute. I think it fits well with the ending. Bu-bye._

src/data/blog-list.ts

@@ -11,8 +11,7 @@ export const BLOGS: BlogType[] = [
     publishDate: 'May 2026',
     readTime: '19 min read',
     tags: ['#llm', '#ollama', '#gemma4'],
-    blogUrl:
-      'https://dev.to/devengers/should-you-use-gemma-4-for-your-development-a-multiversal-analysis-to-determine-if-gemma-4-is-2iol',
+    blogUrl: `/blog/${getSlug('Should you use Gemma 4 for your Development? A Multiversal Analysis to Determine if Gemma 4 is Right for You!')}`,
     imgUrl: '/img/blog-1.webp',
     imgAlt:
       'A collection of anime characters for a multiversal collaboration for an article.',
@@ -26,8 +25,7 @@ export const BLOGS: BlogType[] = [
     publishDate: 'June 2026',
     readTime: '15 min read',
     tags: ['#opensource', '#machinelearning', '#copilot'],
-    blogUrl:
-      'https://dev.to/devengers/two-devs-and-a-copilot-created-classifierai-a-prototype-chrome-extension-that-automatically-4fge',
+    blogUrl: `/blog/${getSlug('Two Devs and a Copilot Created ClassifierAI: A Prototype Chrome Extension that Automatically Detects AI-Generated Content on DEV!')}`,
     imgUrl: '/img/blog-2.webp',
     imgAlt:
       'A funny backgroups GIF image where Elmar and Francis are dancing with strange creatures.',
@@ -56,6 +54,19 @@ export const BLOGS: BlogType[] = [
     imgUrl: '/img/blog-4.jpg',
     imgAlt: 'Keyboard caps laid down on a white table.',
   },
+  {
+    id: 5,
+    title: 'The Slow and Quiet Cognitive Atrophy of a Modern Software Engineer',
+    description:
+      'My thoughts on AI dependency and why struggling through problems is still one of the best ways to combat cognitive atrophy and become a better engineer.',
+    publishDate: 'September 2026',
+    readTime: '8 min read',
+    tags: ['#ai', '#programming', '#software'],
+    blogUrl: `/blog/${getSlug('The Slow and Quiet Cognitive Atrophy of a Modern Software Engineer')}`,
+    imgUrl: '/img/blog-5.webp',
+    imgAlt:
+      'A painting of six blind men stumbling, depicting of a tragedy when following without thinking.',
+  },
 ];
 
 export const blogList: BlogType[] = BLOGS.slice(-3).reverse();