Forem: joedev090

📚 AI Skills for Software Developers: Zero to Expert Guide 🤖

joedev090 — Thu, 26 Feb 2026 01:30:31 +0000

🌟 Introduction

AI is no longer just about "generating text" or "creating images." Today, skills enable AI agents to perform specialized, modular, and collaborative tasks, completely transforming how we develop software. In this guide, we’ll take you from the basics to advanced implementation of skills, using practical examples and real resources. Let’s dive in! 💡

1️⃣ What Is an AI Skill?

A skill is an atomic, reusable ability that an AI agent can execute. Think of it as a function in programming, but designed for specific AI tasks.

Example:

Skill "SummarizeDocument" → Takes a PDF and returns a summary.
Skill "TranslateCode" → Converts code from Python to JavaScript.

🔍 Why Are Skills Important?

Modularity: Reuse logic across different projects.
Specialization: Each skill does one thing, but does it very well.
Collaboration: Skills can be combined to solve complex problems.

2️⃣ Key Concepts to Understand Skills

AI Agents
An agent is a program that acts autonomously to perform tasks. It can be as simple as a chatbot or as complex as a DevOps automation system.
Subagents
Subagents are smaller, specialized agents that use one or more skills to perform part of a larger task.

Example: A "CodeValidator" subagent might use the "DetectErrors" and "CheckBestPractices" skills.

MCP (Model Context Protocol) A protocol that allows multiple agents/subagents to share context and collaborate. It’s like HTTP for communication between AI agents.

3️⃣ How Do Skills Work? (Step by Step) 🛠️

Step 1:
Skill Discovery

Skills are organized in folders, each containing a SKILL.md file with metadata (name, description, instructions).

/skills/
  ├── SummarizeDocument/
  │   ├── SKILL.md
  │   └── script.py
  └── TranslateCode/
      ├── SKILL.md
      └── script.py

Step 2:
Loading Metadata

At startup, the agent scans skill folders and loads metadata (name, description) from the SKILL.md file.

Recommended format (frontmatter in SKILL.md):

---
name: SummarizeDocument
description: "Summarizes a document in 3 paragraphs."
---

Step 3:
Injecting into Agent Context

Skill metadata is included in the system prompt so the model knows what skills are available.

Example in XML (for models like Claude)

<available_skills>
  <skill>
    <name>SummarizeDocument</name>
    <description>Summarizes a document in 3 paragraphs.</description>
    <location>/skills/SummarizeDocument/SKILL.md</location>
  </skill>
</available_skills>

Step 4:
Activation and Execution

When the agent receives a task, it finds the relevant skill and executes the associated script.

Example:
User requests: "Summarize this PDF."
Agent activates the "SummarizeDocument" skill and runs script.py.

4️⃣ Approaches to Skill Integration

🖥️ A. Filesystem-Based Agents

Operate in a Unix/Bash environment.
Skills are activated via shell commands (e.g., cat /skills/SummarizeDocument/SKILL.md).

Advantage: Direct access to system resources.

🛠️ B. Tool-Based Agents

Do not require a filesystem environment.
Implement custom tools to trigger skills.

Advantage: More flexible and portable.

5️⃣ Security Considerations 🔒
When executing scripts, it’s critical to:

Sandboxing: Run scripts in isolated environments.
Allowlisting: Only allow skills from trusted sources.
Confirmation: Ask for user permission before running risky operations.
Logging: Record all executions for auditing.

6️⃣ Practical Implementation
📚 A. Reference Library: skills-ref
The skills-ref library (Python) provides utilities for working with skills: (https://github.com/agentskills/agentskills/tree/main/skills-ref)

Validate skill directories.
Generate XML for agent prompts.

from skills_ref import validate_skill, generate_skills_xml

# Validate a skill
validate_skill("/skills/SummarizeDocument")

# Generate XML for the agent prompt
skills_xml = generate_skills_xml("/skills/")
print(skills_xml)

📝 B. Example Skill: "SummarizeDocument"

Skill structure:

/skills/SummarizeDocument/
  ├── SKILL.md
  └── script.py

Content of SKILL.md

---
name: SummarizeDocument
description: Summarizes a document in 3 paragraphs.
---

Script

def summarize(document):
    # Logic to summarize using AI
    return summary

7️⃣ Real-World Example: E-Commerce System with Skills 🛒
📦 Scenario:

A user places an order on an online store.
🔄 Flow with Skills and MCP:

"Frontend" Agent: Receives the order.
"Inventory" Subagent: Checks stock (skill: "CheckStock").
"Payments" Subagent: Processes payment (skill: "ProcessPayment").
"Shipping" Subagent: Generates shipping label (skill: "GenerateLabel").
Result: The order is completed in seconds, with each subagent specialized in its task. ✅

8️⃣ Resources to Learn More 📚

Documentation: Agent Skills (https://agentskills.io/) Libraries:
- skills-ref (Python) (https://github.com/agentskills/agentskills/tree/main/skills-ref)
- AutoGen (Microsoft) (https://github.com/microsoft/autogen)

Communities:

AI forums on Stack Overflow and Discord.
Open skill repositories on GitHub.

Conclusion: The Future Is Modular 🌐

Skills are democratizing AI development, allowing any developer to create intelligent systems without being a machine learning expert. Start with a simple skill, experiment, and scale. The future of AI is collaborative and modular! 🚀

Skills like MCP comes to make a revolution on the GEN AI era, be part of this, so let's learn more about it!! :)

See you coders, hope this article is useful, let me know if you want to add something else or we can check about this article...

🚀 2026 Software Development Roadmap: How to Start (or Reinvent) Your Career in Tech

joedev090 — Sat, 07 Feb 2026 16:04:35 +0000

💡 Why 2026 Is the Perfect Year to Jump Into Tech

The tech industry isn’t just growing—it’s exploding. With 350,000+ new jobs annually in the U.S. alone, there’s never been a better time to start (or pivot) your career. Whether you’re a complete beginner, a junior dev looking to level up, or a seasoned programmer stuck in legacy tech, this guide is your no-BS roadmap to thriving in 2026.

Here’s the truth:
✅ Companies are desperate for skilled talent.
✅ Salaries are higher than ever (even for remote roles).
✅ You don’t need a CS degree—just the right skills and hustle.
✅ Legacy devs: Your experience is gold—you just need to modernize it.

Let’s break it down. No fluff. Just actionable advice.

🎯 Step 1: Pick One Path (Stop Trying to Learn Everything!)

The biggest mistake I see?
People jumping between languages/frameworks without mastering any. In 2026, companies want specialists, not jacks-of-all-trades. Here’s how to choose:

🔥 Best Entry-Level Roles for Beginners (Low Barrier, High Demand)

1.- Cloud Engineer 🌥️

What you’ll do:
Build and manage cloud infrastructure (AWS, Azure, GCP).
Why it’s great:
6M+ job openings worldwide. Certifications like AWS Certified Cloud Practitioner can get you hired in 3–6 months.
Salary: U.S.: $110K–$160K
LatAm/Europe: €30K–€60K (remote jobs pay more!).
Perfect for: Beginners who want a fast, stable entry into tech.

2.- Full-Stack Developer 💻

What you’ll do:
Build both frontend (React, Vue) and backend (Node.js, Django).
Why it’s great:
Startups and scale-ups love versatile devs. You can transition into architecture or AI later.
Salary: U.S.: $80K–$130K
LatAm/Europe: €25K–€50K (remote: up to $70K).
Perfect for: Creators who enjoy seeing their code come to life.

3.- Data Analyst 📊

What you’ll do: Turn raw data into actionable insights (SQL, Python, Tableau).
Why it’s great: 30–35% annual growth. Easier to break into than Data Science.
Salary:
U.S.: $70K–$100K
LatAm/Europe: €30K–€50K.
Perfect for: Logical thinkers who love solving puzzles with data.

💎 Mid-Level Roles for Upskilling (Higher Pay, More Challenge)

1.- DevOps Engineer 🔄

What you’ll do: Automate CI/CD pipelines, manage Kubernetes, and bridge dev + ops.
Why it’s great: High demand, but not for absolute beginners (need sysadmin/scripting experience).
Salary: U.S.: $100K–$140K, LatAm/Europe: €40K–€70K.
Perfect for: Devs who love automation and scalability.

2. Cybersecurity Specialist 🛡️

What you’ll do: Protect systems from attacks, implement security protocols.
Why it’s great: 3.5M+ unfilled jobs. Zero risk of AI replacement.
Salary: U.S.: $90K–$150K (seniors: $250K+)
LatAm/Europe: €40K–€70K.
Perfect for: Paranoid problem-solvers (in a good way!).

3.- Blockchain Developer ⛓️

What you’ll do:
Build smart contracts (Solidity, Rust) for DeFi, NFTs, and Web3.
Why it’s great:
Niche but lucrative. Companies pay premium salaries for blockchain expertise.
Salary: U.S.: $120K–$180K
LatAm/Europe: €45K–€80K.
Perfect for: Devs fascinated by decentralization and crypto.

🚀 Advanced Roles (For Experienced Devs Ready to Specialize)

1.- AI/ML Engineer 🤖

What you’ll do: Build machine learning models (TensorFlow, PyTorch).
Why it’s great:
Highest salaries in tech, but not beginner-friendly (requires math + CS fundamentals).
Salary: U.S.: $120K–$180K
LatAm/Europe: €50K–€80K.
Perfect for: Devs who love algorithms and innovation.

2.- Software Architect 🏗️

What you’ll do:
Design large-scale systems (microservices, cloud-native apps).
Why it’s great:
Top-tier salaries ($200K+ in the U.S.). Requires years of experience.
Perfect for: Senior devs ready to lead technical vision.

🛠️ Step 2: How to Break Into Tech (Even Without Experience)

👉 If You’re a Complete Beginner:

✅ Pick one role (Cloud, Full-Stack, or Data Analyst)
Get certified:
Cloud: AWS Cloud Practitioner
Full-Stack: The Odin Project (free!)
Data: Google Data Analytics Certificate (Coursera).

✅ Build projects:
Cloud: Deploy a serverless app on AWS.
Full-Stack: Create a CRUD app (e.g., a task manager).
Data: Analyze a public dataset (Kaggle) and publish insights.

✅ Apply to jobs:
Use LinkedIn, AngelList, and RemoteOK.
Pro tip: Start with startups or freelance gigs to gain experience.

👉 If You’re a Legacy Dev (COBOL, PHP, VB, etc.):

Leverage your experience:

✅ Your problem-solving skills are timeless
Learn one modern stack (e.g., JavaScript + React + Node.js).

✅ Transition gradually:
Example: If you know PHP, learn Laravel (still in demand).
If you know SQL, pivot to Data Engineering.

✅ Highlight transferable skills:
Debugging, system design, and legacy system maintenance are valuable.

👉 If You’re a Junior Dev Looking to Level Up:

Specialize:

✅ Pick one advanced area (DevOps, Cybersecurity, AI).
✅ Contribute to open-source:
✅ GitHub is your resume.
✅ Network aggressively:
Join Dev.to, Stack Overflow, and local meetups.

⚠️ Step 3: Avoid These Costly Mistakes

❌ Learning obsolete tech (e.g., VB6, Flash).
Fix: Focus on cloud, JavaScript, Python, or Go.

❌ Ignoring soft skills.
Fix: Practice explaining technical concepts simply.

❌ Not building a portfolio.
Fix: GitHub + personal website = your ticket to interviews.

❌ Skipping English.
Fix: Remote jobs pay in USD—English is non-negotiable.

💰 Step4: Salary Expectations:

✅ Pro tip: Remote jobs (especially in U.S./EU companies) can 2–3x your salary if you’re outside the U.S.

🎓 Step 5: Resources to Get Started Today

Goal,Free/Paid Resources

Learn Cloud,AWS Free Tier,
A Cloud Guru
Learn Full-Stack,The Odin Project, Scrimba
Learn Data Analysis,Kaggle, Google Data Analytics Certificate
Learn DevOps,Kubernetes Basics, DevOps Bootcamp (Udemy)
Learn Cybersecurity,TryHackMe, Cybrary
Learn Blockchain,CryptoZombies, Solidity Docs

🚀 Final Advice: Your 2026 Action Plan

This week: Pick one role from this guide.
This month: Start a certification or course.
Next 3 months: Build 2–3 portfolio projects.
Next 6 months: Apply to 10+ jobs/day (yes, it’s a numbers game).
Always: Network, contribute to open-source, and keep learning.

💬 Your Turn!

👉 Which path excites you the most? Cloud? Full-Stack? AI?

Drop a comment below—I’ll help you craft a personalized roadmap!

P.S. If you found this useful, share it with a friend who’s thinking about tech. Let’s get more people into this life-changing industry! 🚀

🚀 The Essential Patterns Behind Modern AI Agents

joedev090 — Wed, 03 Dec 2025 00:59:36 +0000

🚀 The Essential Patterns Behind Modern AI Agents

A Practical Guide for Developers, PMs, Analysts & Business Leaders

✅ Artificial Intelligence agents are quickly becoming the backbone of next-generation software systems. They automate decision-making, coordinate tasks, call APIs, analyze data, and even interact with users like mini-employees who work 24/7.

Regardless of the framework you use (LangChain, LangGraph, CrewAI, LlamaIndex, AutoGPT…), the smartest AI agents rely on the same set of architectural patterns.

✅ Understanding these patterns is the difference between:

Building a confusing chatbot, or
Designing a reliable multi-agent system that solves real business problems.

This article breaks them down in a simple, real-world, business-friendly way.

🧩 What Is an AI Agent, Really?

✅ Think of an AI agent as a software component with initiative:

It reads an instruction
Decides what needs to be done
Uses tools, APIs, or other agents
And delivers a result

✅ This makes agents useful not only for developers, but also for:

Customer support automation
Logistics and operational workflows
Financial analysis
Marketing content creation
Data cleanup
Decision-making pipelines

✅ The magic is NOT the tools — it’s the patterns behind the architecture.

🧱 The 5 Core Patterns Behind Every Effective AI Agent

1️⃣ Chaining Pattern — Step-by-Step Workflows

This pattern executes a sequence of steps, one after another.

🔍 Real-world example:

Flight-change notifications for an airline
Extract flight details from an internal system
Ask the LLM to classify if the message needs an apology or not
Generate a personalized message
Validate tone before sending

This is a classic chain:
Input → Process → Transform → Output

Simple, predictable, powerful.

2️⃣ Routing Pattern — Direct Users to the Right Specialist

A routing agent acts like a triage nurse in a hospital:
It reads the request and decides which specialized agent should handle it.

🔍 Real-world example:

Customer Support in E-commerce

A routing agent receives a message:

“My package arrived broken.” → Send to Claims Agent
“I want to change my delivery address.” → Send to Order Modification Agent
“How do I return an item?” → Send to Self-Service FAQ Agent

Routing turns one big bot into a coordinated team of experts.

3️⃣ Parallelization Pattern — Multiple Agents Working at Once

Instead of running tasks one by one, this pattern launches several agents simultaneously.

🔍 Real-world example:

Code Review Automation

A developer submits code.
Three AI agents run in parallel:

🔐 Security Agent checks for vulnerabilities
🎨 Style Agent checks formatting and conventions
⚙️ Complexity Agent analyzes maintainability

The orchestrator merges results into a single, clean review.

Parallelization = speed.

4️⃣ Orchestrator Pattern — The Project Manager Agent

The orchestrator doesn’t do the tasks.
It manages agents that do the tasks.

It’s like a PM assigning work to the right specialists.

🔍 Real-world example:

Launching a new product landing page

Orchestrator receives request
Assigns tasks:
UX Agent → Write the main message
Marketing Agent → Create persuasive copy
Technical Agent → Generate HTML/CSS
Orchestrator merges and finalizes
Returns a complete project output

This enables scalable teamwork between AI agents.

The last pattern is awesome!!

5️⃣ Evaluator Pattern — AI Checking AI

This pattern lets one agent evaluate the output of another.

🔍 Real-world example:

✅ Financial email generation

Agent A generates the financial explanation
Evaluator Agent checks:

Accuracy
Tone compliance
Clarity

If it fails, evaluator requests improvement until it meets standards

Evaluators reduce errors and add control.

🎯 Why These Patterns Matter (Even if You’re Not an Engineer)

Whether you’re a developer, PM, analyst, or business leader:

✅ They help you design better AI solutions

Knowing the patterns lets you break down complex problems strategically.

✅ They prevent over-engineering

Most business use cases don’t need a “super-agent”—just the right pattern.

✅ They make your product scalable

As your workload grows, patterns give structure and reliability.

✅ They align tech and business teams

Patterns act as a shared vocabulary between engineering, product, and ops.

🧠 Final Takeaway

You don’t need to memorize every AI framework.
You only need to understand the patterns.

✅ These five concepts — chaining, routing, parallelization, orchestration, and evaluation — will allow you to design, analyze, and implement AI systems that are:

Scalable
Maintainable
Aligned with business goals
And capable of real, measurable value

AI agents aren’t magic.
They’re architecture — just like any good software system

What do you think about these patterns? Are there one is most used or maybe we have to add a new one?

This article is based on this youtube video made by #nicobytes:

https://www.youtube.com/watch?v=oR0GqQ8wMfk

🚀 Lean Startup: La guía moderna para crear productos que la gente realmente quiere

joedev090 — Sat, 22 Nov 2025 17:12:55 +0000

Cada vez mas me sorprende como la metodologia Lean Startup puede hacer que suceda cosas maravillosas, tanto en proyectos empresariales como en startups.

Pero Eric Ries, con su libro The Lean Startup, propone algo distinto: una forma más científica, ágil y basada en datos para crear productos exitosos bajo incertidumbre.

Este artículo resume sus ideas principales de forma clara y accionable 👇

1️⃣ ¿Qué es Lean Startup?

Lean Startup es un método que ayuda a emprendedores y equipos de producto a minimizar el desperdicio, aprender rápido y construir solo lo que realmente importa.

Se basa en ciclos cortos de experimentación, observación del cliente y decisiones guiadas por datos, no por suposiciones.

Es ideal para startups, proyectos de innovación o cualquier iniciativa que se desarrolle en ambientes de incertidumbre.

2️⃣ Principios Fundamentales del Método

2.1 Emprendedores en todas partes 👥
No importa si estás en una startup, en una corporación o creando un proyecto paralelo: el espíritu emprendedor puede surgir en cualquier lugar donde haya innovación.

2.2 El emprendimiento es management 📊
Crear un producto nuevo requiere un estilo de gestión especial, diferente al tradicional, porque las decisiones se toman con información incompleta.

2.3 Aprendizaje Validado 🎯
El objetivo principal de una startup no es lanzar rápido, sino aprender rápido.
Cada hipótesis sobre tu producto debe validarse con experimentos reales.

2.4 El Ciclo Crear → Medir → Aprender 🔁
El corazón del método Lean:

Crear un experimento o prototipo mínimo
Medir cómo reaccionan los usuarios
Aprender qué funciona y qué no

Este ciclo debe repetirse constantemente.

2.5 Contabilidad de la Innovación 📈
Para saber si una idea progresa, se necesitan métricas reales (retención, conversión, uso), no “métricas vanidosas” como vistas o likes.

3️⃣ Parte 1: Ver – Descubriendo Qué Quiere el Cliente

3.1 Operar bajo incertidumbre extrema 🌫️
Las startups no deben seguir procesos corporativos rígidos, porque no saben todavía qué producto será viable.

3.2 El objetivo: Aprendizaje validado 🧪
Formular hipótesis, ejecutar experimentos y obtener feedback real.
Ej.: Zappos probó la demanda comprando zapatos en tiendas locales antes de invertir en inventario.

3.3 Observar comportamientos, no opiniones 👁️
Preguntar al usuario no basta; lo importante es ver cómo se comporta realmente.

3.4 Casos reales como ejemplo 🌍
Zappos validando demanda con fotos de zapatos en su web.
Lavandería móvil en India adaptando su modelo al comportamiento real del usuario.

4️⃣ Parte 2: Dirigir – Pasar del Aprendizaje a la Acción

4.1 Construcción de un MVP (Minimum Producto Viable) 🧩
Un MVP no es un prototipo bonito: es la versión más simple que te permite aprender algo real.

Tipos de MVP:

Landing Pages 🖥️
Videos explicativos 🎥
PMV “Conserje” (servicio manual personalizado) 🤝
PMV “Mago de Oz” (parece automatizado, pero detrás hay humanos) 🪄

4.2 Hipótesis de valor y de crecimiento 📐
Valor: ¿El usuario realmente usa y valora esto?

Crecimiento: ¿Cómo se expandirá el negocio?

4.3 Métricas que importan 📊
Evitar métricas vanidosas y enfocarse en:

Retención
Conversión
Engagement

4.4 Test A/B para validar decisiones 🔬
Experimentar comparando dos versiones y ver cuál funciona mejor.

4.5 Pivotar o perseverar 🔄
Si las métricas no mejoran, es necesario un pivot.
Ries sugiere revisiones periódicas para decidirlo antes de agotar recursos.

5️⃣ Parte 3: Acelerar – Escalar sin Perder Agilidad

5.1 Lotes pequeños para mejorar más rápido ⚡
Iteraciones pequeñas permiten detectar errores pronto y aprender más rápido.

5.2 Crecimiento sostenible 🌱
Cuatro formas principales:

Publicidad
Repetición del negocio
Recomendación entre usuarios
Efecto red

5.3 Lograr el “Product-Market Fit” 🧲
Cuando los usuarios reconocen el valor del producto y lo adoptan masivamente.

5.4 Resolver problemas con los “Cinco Porqués” ❓❓❓❓❓
Técnica para descubrir la causa raíz de un error.

5.5 Innovación sostenida vs. disruptiva ⚔️
Sostenida: mejoras incrementales

Disruptiva: productos nuevos y radicales
Los equipos de innovación deben tener autonomía para ejecutar ambos enfoques.

Finalmente:

6️⃣ Conclusión: Construir con Menos Riesgo y Más Aprendizaje 💡

Lean Startup enseña a reducir desperdicio, acelerar el aprendizaje y crear productos que la gente realmente quiera.
No se trata de moverse más rápido por moverse: se trata de aprender rápido, medir lo que importa y tomar decisiones basadas en evidencia.

Si estás lanzando un producto, un MVP o un experimento interno, aplicar Lean Startup puede marcar la diferencia entre un proyecto exitoso y meses de trabajo desperdiciado.

Como parte de la industria del desarrollo de Software el tener presente esta metolodogia nos ayudara a aliviar muchos dolores de cabeza, ya sea cuando empecemos nuestro propio startup o participemos en un proyecto a nivel empresarial!!!

Nuestra mente emprendedora, tarde o temprano sale a florecer!!!

Que piensas de esta metodologia? Crees que la podamos mezclar con otros metodos agiles?

Dejame tu comentario o tu like, para que llegue a mas personas...

Nos vemos Coders y amigos!

🚀 Coding 3 Faster with PM Knowledge: Why True Speed Comes from Team Alignment, Not Typing Faster

joedev090 — Fri, 24 Oct 2025 01:34:04 +0000

Hey Coders

Context:
I was checking latest posts from my Linkedin and I realized about a new video of one of my mentors in the past #faztcode (you can see your videos in youtube).

The title of the video caught my attention...

"Code 3x Faster without AI"
"Programar 3 veces más rápidos (y sin usar IA)"

Here you can see the link of the video:

When I was watching the video, I checked the reference it mentioned, and I was more curious about the post, so I checked it before finishing to watch the video (believe it or not! hehe).

The title of the post was a little different and caught more my attention.

I decided to read but like most of the articles in medium, it was not able all the reading.
So I decided to use the AI to help me to create a brief of the video and most of the things are often true, and maybe it was the perspective of the author about "How to code 3x faster than my team even when he is not using some help for the AI" (curious) but at the mostly of the things are true.

This article is not a resume about that article (you can see at the end of this reading), I copied the title and adding my perspective based on my experience in different projects on the software development.

Let's begin!!!

**_

🚀 Coding 3× Faster with PM Knowledge: Why True Speed Comes from Team Alignment, Not Typing Faster

_**

💡 The Myth of the “Fast Developer”

We all know that one engineer who seems to deliver features at lightning speed.
They merge code quickly, demo constantly, and always seem “ahead.”

Early in my career, I thought these people just coded faster. Later, I learned the truth: speed in software is not a typing skill — it’s a thinking skill.

But here’s the twist most developers miss:

The fastest developers think like Product Managers.

They don’t chase perfection in code. They chase clarity of purpose, scope, and impact — the same things great PMs obsess over.

🧭 Think Like a Project Manager (PM): Clarity Before Code

A PM doesn’t start by asking “How do we build this?”
They ask “Why are we building this, and what’s the smallest thing that solves it?”

💡 When developers adopt that mindset, something incredible happens:

You stop wasting time on low-value features.
You naturally prioritize impact over polish.
You deliver the right thing, not just a thing.

Before you open your IDE, ask yourself:

What user problem am I solving?
What’s the smallest valuable outcome that proves it works?
What can I cut or simplify without losing impact.

That’s Lean Inception 101 — and it’s how great teams move from idea to MVP in weeks, not months.

🧩 MVPs and Lean Inception: Build, Measure, Learn — Fast

A Lean Inception aligns the team on the vision, users, and scope of the MVP.
It’s where everyone — PMs, designers, and devs — agrees on:

The problem to solve.
The personas who face it.
The MVP features that validate the idea.

As developers, when we embrace this process, we gain directional clarity.
We stop over-engineering because we know exactly what must exist for the MVP to succeed.

That’s how you code 3× faster — not by skipping tests, but by skipping the non-essential.

🧠 From Agile Theory to Real Velocity: Scrum + Kanban in Action

Many teams say they’re “Agile,” but still struggle to release fast.
Why? Because agility without focus is chaos.

Here’s how Agile methods enable real speed:

Scrum: Sprint Toward Value

Scrum creates rhythm and focus. Short sprints (1–2 weeks) force scope discipline.
Each sprint review is a checkpoint to validate if the team is building what truly matters.

Deliver something demo-ready every sprint — even if it’s small.
That forces clarity, collaboration, and continuous integration.

Kanban: Flow, Not Rush

When teams need flexibility or continuous delivery, Kanban keeps things flowing.

Visualizing your workflow exposes bottlenecks: long QA queues, endless code reviews, or unclear acceptance criteria.

By tightening those loops, you speed up flow, not just coding.

Both frameworks remind us that team speed is system speed.

A single “fast developer” means nothing if reviews, blockers, and unclear stories slow everyone else down.

🤝 The Power of Team Alignment

Coding 3× faster is not about cutting corners — it’s about removing friction.

You can’t go fast if:

The requirements change mid-sprint.
Designers and devs don’t share context.
QA gets code that’s hard to test.
PMs expect magic without clarity.

That’s why the best developers don’t isolate themselves — they collaborate early.
They ask questions in refinement, challenge assumptions in planning, and offer tech insights during design reviews.

When devs, PMs, and designers move in sync, velocity compounds.
What took 3 weeks now takes 5 days — not because anyone types faster, but because everyone understands the goal.

And finally...

⚖️ Good Enough vs. Sustainable

One trap of “speed culture” is confusing speed with haste.
The goal isn’t sloppy code — it’s focused iteration.

A fast team:

Writes maintainable “good-enough” code for the MVP.

Keeps a refactor backlog to revisit critical parts later.

Avoids premature abstraction, but maintains testability.

Remember: The MVP is not the final product. It’s a learning tool.
You build it fast to validate assumptions, not to last forever.
Once validated, you harden, refactor, and scale.

🧩 Code Fast, Think Lean, Ship Together

In the end, speed in software isn’t about lines of code per hour.
It’s about how fast your team can learn.

A Product Manager’s mindset helps developers see the bigger picture.

Agile frameworks provide the structure to learn quickly.

Lean Inception ensures that what we ship actually matters.

So if you want to “code 3× faster,” stop optimizing your keystrokes.
Start optimizing your clarity, collaboration, and feedback loops.

This post is based on this article:
https://medium.com/@jh.baek.sd/why-i-code-3x-faster-than-my-team-and-its-not-what-you-think-390e6e6078d0

And this video:
https://www.youtube.com/watch?v=vxQqjMSmQxM

IA Generativa en 2025: Cómo sobrevivir y prosperar en la nueva era tecnológica

joedev090 — Sun, 28 Sep 2025 22:23:16 +0000

La inteligencia artificial generativa (IA generativa) dejó de ser un concepto de ciencia ficción.

Hoy escribe textos, crea ilustraciones, compone música e incluso programa código en segundos. Lo que antes parecía magia, ahora está en la oficina, la universidad y hasta en el celular.

En este artículo te contaré qué es, cómo funciona, qué oportunidades trae y cuáles son los riesgos que debemos considerar para aprovecharla de forma responsable.

💡 Este artículo está pensado tanto para quienes programan como para quienes coordinan, diseñan o simplemente sienten curiosidad por la tecnología.

¿Qué es la IA generativa?

Es una rama de la IA que no solo analiza datos, sino que genera contenido nuevo.
Solo basta con escribir una instrucción (un prompt) para obtener un artículo, una imagen o un bloque de código.

👉 En 2025 ya no hablamos de un experimento, sino de una herramienta de trabajo y creatividad en múltiples industrias.

Cómo funciona: la magia detrás del contenido

Los modelos se entrenan con millones de ejemplos y aprenden patrones. Gracias a un mecanismo llamado “atención” (attention), el sistema elige la información más relevante para dar una respuesta coherente.

Ejemplo sencillo: si escribes “hazme una lista de tareas para organizar un evento”, el modelo no copia de internet, sino que predice las palabras más probables y crea un plan nuevo.

Modalidades y multimodalidad

Hasta hace poco teníamos modelos especializados (texto → texto, texto → imagen). La tendencia actual son los modelos multimodales: entienden y combinan texto, imágenes, audio y video en la misma interacción.

🎬 Imagina describir una idea en palabras y recibir un video corto como resultado.

Limitaciones y riesgos

Aunque suene increíble, la IA generativa tiene problemas:

Alucinaciones: puede inventar datos que parecen ciertos.

Conocimiento limitado: no sabe lo ocurrido después de su fecha de entrenamiento.

Sesgos: repite prejuicios presentes en los datos.

Costos ambientales: entrenar modelos consume mucha energía.

Mal uso: desde noticias falsas hasta fraudes visuales.

💡 Consejo: úsala como herramienta, no como única fuente de verdad.

El rol humano en la era de la IA

La IA no viene a reemplazarnos, sino a exigir que potenciemos lo que nos hace únicos: creatividad, pensamiento crítico, ética y empatía.

Los profesionales que prosperen serán los que aprendan a trabajar con la IA, no contra ella.

Aplicaciones prácticas

Algunos ejemplos actuales:

🎓 Educación: asistentes que resumen lecturas o crean ejercicios personalizados.

💼 Negocios: borradores de contratos, reportes o ideas de marketing.

🎨 Arte y diseño: generación de imágenes, música y videos.

👩‍💻 Tecnología: ayuda en la programación y prototipos rápidos.

Agentes autónomos: el siguiente paso

Más allá de “responder preguntas”, están surgiendo los agentes autónomos: programas que encadenan tareas, interactúan con aplicaciones y toman decisiones limitadas sin supervisión constante.
Ejemplo: un asistente que recibe un correo, analiza el pedido, busca información en internet y genera una respuesta automática.

IA en las organizaciones

El verdadero cambio ocurre cuando una empresa integra la IA en sus procesos y cultura, no solo en tareas individuales. Esto requiere:

Liderazgo con visión.

Capacitación constante.

Políticas éticas claras.

Espacios de experimentación.

El arte de preguntar: prompt engineering

El resultado depende de la instrucción. Aprender a dar contexto, ejemplos y objetivos claros es fundamental.
Ejemplo: en vez de escribir “haz un informe”, prueba con:

“Escribe un informe de una página, con viñetas y un resumen final para directivos no técnicos”.

Mirando al futuro

El debate está abierto: ¿liberará nuestro potencial creativo o generará nuevas desigualdades?
Lo único seguro es que la IA generativa ya forma parte de nuestra vida digital y seguirá transformando la forma en que trabajamos y nos relacionamos.

Conclusión

La IA generativa no es una moda: es una revolución en marcha. Nuestro reto no es temerle, sino aprender a usarla con criterio, ética y creatividad.

🔑 Adaptarse es obligatorio, prosperar es la gran oportunidad.

🚀 Lean Startup for Software Developers 💻

joedev090 — Fri, 22 Aug 2025 17:41:12 +0000

Hey Coders!!!

Let's check in more details about Lean Startup, and we will begin for the basic. A definition:

🤔 What is Lean Startup?

Lean Startup is a methodology for creating and managing startups efficiently. The goal? Launch products fast with minimal resources, reducing risk and uncertainty.

🔹 Core Principle: The Build-Measure-Learn cycle 🔄

🛠️ Build:
Develop a Minimum Viable Product (MVP)—a basic version with only essential features.

📊 Measure: Track user responses with data and metrics to validate hypotheses.

🧠 Learn: Analyze results to decide whether to persevere or pivot.

This approach helps you learn quickly what customers really want, avoiding wasted time and money on unwanted products.

📖 Created by Eric Ries and inspired by Toyota’s Lean Manufacturing, it replaces rigid planning with experimentation and feedback.

1️⃣ The Build-Measure-Learn Feedback Loop 🔄

The heart of Lean Startup! Instead of spending months building a "perfect" product, focus on speed to get real feedback.

Example (E-commerce for Sportswear):
💡 Hypothesis: Customers want to customize their jerseys.

🛠️ Build: A simple page where users pick a shirt color and add text (no complex 3D editor).
📊 Measure: Track clicks on "Customize," cart additions, and completed purchases.
🧠 Learn: If users interact but don’t buy, maybe the process is too simple or the price is wrong. Iterate or drop the feature!

2️⃣ Everything Is an Experiment 🧪

Every new feature is a test, not a guess. Base decisions on data, not assumptions!

Example:
💡 Hypothesis: Better product photos = higher conversions.

🎨 Test: A/B test—50% see old photos, 50% see new high-quality ones.
📈 Result: If new photos convert better, invest in professional photography!

3️⃣ Types of MVPs 📦

An MVP isn’t incomplete, it’s the simplest version to test your hypothesis.

Examples:

🎭 Wizard of Oz MVP: Fake a product page (no backend). When orders come in, handle them manually to validate demand.

👔 Concierge MVP: Serve a few customers personally (e.g., email catalogs, phone orders) before automating.

4️⃣ Three Engines of Growth 📈
Once your product is validated, choose a growth strategy:

🧲 Sticky: Focus on retention (loyalty programs, UX).
🦠 Viral: Encourage referrals (e.g., discounts for sharing).
💰 Paid: Scale with ads (measure CAC vs. LTV).

5️⃣ Pivot or Persevere? 🔁

A pivot isn’t failure—it’s a smart course correction based on data.

Example:
💡 Vision: High-performance sportswear.
📉 Data: Running gear gets more searches than cycling.
🔄 Pivot: Shift focus to running while keeping the same vision.

💡 Key Takeaway for Devs:

Lean Startup helps you build what users want without wasting resources. Experiment, measure, and adapt!

🚀 Have you used Lean Startup in your projects?

Share your experience in the comments!

LeanStartup #SoftwareDevelopment #MVP #Agile #ProductManagement #Startups #DevLife #TechTips

Desbloquea el Desarrollo de Software: Los 6 Pilares Fundamentales para Construir Cualquier Aplicación 🚀

joedev090 — Mon, 18 Aug 2025 02:56:30 +0000

Hey Coders!! 👋🏻

👉🏻 ¿Alguna vez te has preguntado qué se necesita realmente para construir una aplicación desde cero y hacerla exitosa?

💡 No es solo escribir código bonito; es un proceso que abarca desde la conceptualización hasta la puesta en marcha.

Basado en la experiencia y en la observación de proyectos exitosos, he identificado 6 pilares esenciales que te proporcionarán una base sólida para cualquier aventura de desarrollo.

¡Vamos a explorarlos!

1 💡 Definición Clara de Requerimientos y Metodologías Ágiles

Este es el verdadero punto de partida. Antes de siquiera pensar en el lenguaje de programación o la base de datos, necesitas entender exactamente qué problema estás resolviendo y para quién. Sin una visión clara, es como construir una casa sin planos.

¿Cómo lograrlo?
La clave está en la comunicación constante con los stakeholders (clientes, usuarios finales, equipos de negocio).
Las metodologías ágiles como Scrum y Kanban son tus mejores aliadas aquí. Te permiten:

Desglosar un gran problema en tareas manejables (historias de usuario).
Priorizar qué funcionalidades son las más importantes para entregar valor temprano.
Iterar y adaptarse a los cambios, asegurando que el producto final satisfaga las necesidades reales.

💡 Visualiza tu Idea:

El Valor Invaluable del Diseño UX 🎨
Una vez que tienes los requerimientos claros, el siguiente paso lógico es visualizarlos.
Aquí es donde el Diseño de Experiencia de Usuario (UX) brilla. No es solo hacer que algo se vea bonito, sino que sea intuitivo, eficiente y agradable de usar.

¿Por qué es crucial?

👉🏻 Mockups y Prototipos: Permiten crear una representación tangible de la aplicación (bocetos, wireframes, prototipos interactivos) antes de escribir una línea de código funcional.

👉🏻 Feedback Temprano: Puedes presentar estos prototipos a los stakeholders y usuarios potenciales. Recibir feedback en esta etapa es mucho más económico y sencillo de implementar que corregir errores de diseño una vez que el código ya está desarrollado. ¡Evita rehacer trabajo!

👉🏻 Claridad para el Equipo: Proporciona una guía visual clara para los desarrolladores, asegurando que todos están construyendo la misma visión.

2 🗄️ Diseño de Bases de Datos Relacionales
Tu aplicación necesitará almacenar datos, y cómo los estructuras es fundamental para su rendimiento y escalabilidad.
Las bases de datos relacionales son el pan de cada día de la mayoría de las aplicaciones web y móviles.

Puntos clave:

👉🏻 Modelado de Datos: Entender cómo las tablas se relacionan entre sí. Piensa en claves primarias (identificadores únicos) y claves foráneas (vínculos entre tablas).

👉🏻 Normalización: Organizar los datos para evitar redundancia y mejorar la integridad. Esto previene inconsistencias y facilita el mantenimiento.

👉🏻 Optimización de Consultas: Saber cómo escribir consultas eficientes (SQL) es vital para que tu aplicación responda rápidamente.

👉🏻 ORM (Object-Relational Mapping): Aunque herramientas como Sequelize, SQLAlchemy o Entity Framework te abstraen de SQL, comprender los principios subyacentes de las bases de datos te permitirá depurar y optimizar eficazmente.

3 🔗 Creación y Consumo de API (Application Programming Interface)

En el mundo interconectado de hoy, las aplicaciones rara vez viven en aislamiento. Las APIs son el lenguaje universal que les permite "hablar" entre sí.

¿Qué necesitas saber?

👉🏻 Protocolo HTTP: La base de la comunicación web (GET, POST, PUT, DELETE).

👉🏻 Diseño RESTful: Un conjunto de principios para diseñar APIs claras y coherentes.

👉🏻 Manejo de Solicitudes y Respuestas: Cómo enviar datos (headers, body) y cómo interpretar las respuestas del servidor (códigos de estado, JSON/XML).

👉🏻 Integración de Servicios Externos: Desde pasarelas de pago (Stripe, PayPal) hasta servicios de mapas (Google Maps) o IA (OpenAI), las APIs te permiten extender funcionalidades sin tener que construirlas desde cero.

4 🔒 Autenticación y Autorización
La seguridad no es una opción, es una necesidad.
Toda aplicación que maneje datos de usuario o funcionalidades sensibles debe tener un sistema robusto para protegerlos.

Conceptos esenciales:

👉🏻 Autenticación: Verificar la identidad de un usuario (por ejemplo, con usuario y contraseña, OAuth, SSO).

👉🏻 Autorización: Definir qué acciones puede realizar un usuario una vez autenticado (roles, permisos).

👉🏻 Manejo de Sesiones/Tokens: Cómo mantener la información del usuario logueado de forma segura (JWTs son muy populares).

👉🏻 Protección de Rutas: Asegurar que solo usuarios autorizados puedan acceder a ciertas partes de tu backend o frontend.

5 🏗️ Principios de Arquitectura de Software
Escribir código que funcione es una cosa; escribir código que sea fácil de entender, mantener, probar y escalar es otra muy distinta.
Una buena arquitectura es la diferencia entre un proyecto que crece y uno que se convierte en una pesadilla.

Ideas clave:

👉🏻 Separación de Responsabilidades: Organiza tu código en módulos lógicos donde cada parte tenga una única razón para cambiar (por ejemplo, "capa de datos", "lógica de negocio", "interfaz de usuario").

👉🏻 Modularidad: Crear componentes reutilizables e independientes que puedan ser fácilmente intercambiados o actualizados.

👉🏻 Evitar el Acoplamiento Fuerte: Diseña tus componentes para que dependan lo menos posible entre sí. Esto facilita los cambios y reduce el riesgo de errores.

👉🏻 Principios SOLID (Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion):
Un conjunto de principios que te guían hacia un diseño de software más robusto y flexible.

6 🌐 Despliegue y Entorno Productivo
Tu aplicación no existe realmente hasta que está accesible para tus usuarios en internet. Llevar un proyecto a producción es un arte en sí mismo.

Aspectos a considerar:

👉🏻 Servidores: Entender qué es un servidor (virtual, físico) y cómo alojar tu aplicación en él.

👉🏻 Plataformas de Despliegue: Conocer opciones como PaaS (Heroku, Vercel), IaaS (AWS EC2, Google Compute Engine) o Serverless (AWS Lambda, Azure Functions).

👉🏻 Configuración de Dominio y SSL: Hacer que tu app sea accesible a través de un nombre de dominio amigable y segura con certificados SSL/TLS.

👉🏻 Variables de Entorno: Gestionar configuraciones sensibles (claves de API, credenciales de DB) de forma segura.

👉🏻 CI/CD (Integración Continua/Despliegue Continuo): Automatizar el proceso de pruebas y despliegue para lanzar nuevas versiones de forma rápida y confiable.

👉🏻 Monitoreo y Logs: Saber qué está pasando en tu aplicación en producción y cómo depurar problemas cuando surgen.

Conclusion:

Dominar estos seis pilares no solo te convertirá en un mejor desarrollador, sino que te dará la confianza y las herramientas para transformar cualquier idea en una aplicación funcional y exitosa.

¿Cuál de estos pilares te parece el más crítico o el más desafiante? ¡Me encantaría conocer tu perspectiva y experiencias en los comentarios!

See you coders!! :)

Este post es basado en un video que vi por el creador de contenido en youtube #fazt

https://www.youtube.com/watch?v=WxUmv1Mk1Nw

Create API with NestJS using TDD approach, part 3!!

joedev090 — Fri, 08 Aug 2025 19:46:46 +0000

Hey Coders!!!

Let's continue with the last part of my project on NestJS using TDD approach.

Remember the core concepts!

Write a Failing Test:
The first step in the TDD cycle is to write a test for a small piece of functionality that you want to implement
Write Minimal Code to Pass the Test:
The next step is to write the minimal amount of code necessary to make the test pass
Refactor the Code:
Once the test is passing, the final step is to refactor the code to improve its structure and readability.

This cycle, often referred to as "Red-Green-Refactor," ensures that you always have a working version of your code and that all parts of your codebase are covered by tests.

We have to add the removed functionality, so let's write our tests for the service in
src/properties/test/properties.service.spec.ts

// remove
  describe('remove', () => {
    it('should remove a property', async () => {
      const mockProperty = {
        id: 1,
        name: 'Test Property',
        description: 'Test Description',
        location: 'Test Location',
        imageUrl: 'http://example.com/image.jpg',
        unitsAvailable: 5,
        hasWifi: true,
        hasLaundry: false,
      };

      // Mockeamos la búsqueda de la propiedad
      jest.spyOn(repository, 'findOne').mockResolvedValue(mockProperty);
      // Mockeamos la eliminación
      jest.spyOn(repository, 'remove').mockResolvedValue(mockProperty);

      const result = await service.remove(1);

      expect(result).toEqual(mockProperty);
      expect(repository.findOne).toHaveBeenCalledWith({ where: { id: 1 } });
      expect(repository.remove).toHaveBeenCalledWith(mockProperty);
    });

    it('should throw NotFoundException if property does not exist', async () => {
      // Mockeamos que la propiedad no se encuentra
      jest.spyOn(repository, 'findOne').mockResolvedValue(null);

      await expect(service.remove(999)).rejects.toThrow(NotFoundException);
      expect(repository.findOne).toHaveBeenCalledWith({ where: { id: 999 } });
      expect(repository.remove).not.toHaveBeenCalled();
    });
  });

Using the Tdd approach, run the test with

npm run test

We will check some issues, we are missing the function, that is the next part will be adding in properties.service.ts

async remove(id: number): Promise<Property> {
        const propertyToRemove = await this.propertiesRepository.findOne({ where: { id } });
        if (!propertyToRemove) {
            throw new NotFoundException(`Property with ID ${id} not found.`);
        }
        await this.propertiesRepository.remove(propertyToRemove);
        return propertyToRemove;
    }

After this we run the tests again with npm run test.

We will have one issue, we are missing the remove part in the mockRepository on the beforeEach part.

beforeEach(async () => {
    const mockRepository = {
      find: jest.fn().mockResolvedValue([]),
      findOne: jest.fn().mockImplementation((options) =>
        options.where.id === 999
          ? Promise.resolve(null)
          : Promise.resolve({
              id: 1,
              name: 'Test Property',
              description: 'Test Description',
              location: 'Test Location',
              imageUrl: 'http://example.com/image.jpg',
              unitsAvailable: 5,
              hasWifi: true,
              hasLaundry: false,
            }),
      ),
      create: jest.fn().mockImplementation((dto) => dto),
      save: jest
        .fn()
        .mockImplementation((property) =>
          Promise.resolve({ id: 1, ...property }),
        ),
      remove: jest.fn().mockImplementation((property) =>
        Promise.resolve(property),
      ),
    };

    const module: TestingModule = await Test.createTestingModule({
      providers: [
        PropertiesService,
        {
          provide: getRepositoryToken(Property),
          useValue: mockRepository,
        },
      ],
    }).compile();

    service = module.get<PropertiesService>(PropertiesService);
    repository = module.get<Repository<Property>>(getRepositoryToken(Property));
  });

Then run the tests

npm run test

Wuhuuuu!!! we have only to add the controller part.

Let's work on this, the next part is creating the tests for the controller

In src/properties/test/properties.controller.spec.ts

We will add this code

describe('remove', () => {
      it('should remove a property', async () => {
          const mockProperty = {
              id: 1,
              name: 'Test Property',
              description: 'Test Description',
              location: 'Test Location',
              imageUrl: 'http://example.com/image.jpg',
              unitsAvailable: 5,
              hasWifi: true,
              hasLaundry: false,
          };

          // Mockeamos la función remove del servicio
          (service.remove as jest.Mock).mockResolvedValue(mockProperty);

          const result = await controller.remove(1);

          expect(result).toEqual(mockProperty);
          expect(service.remove).toHaveBeenCalledWith(1);
      });
  });

We learned from the previous function, so let's add the part in the mockRepository in the same file

remove: jest.fn().mockImplementation((id: number) =>
        Promise.resolve({ id }),
      ),

We know if we run the testing, it will fail.

npm run test

We are missing the remove function in

src/properties/properties.controller.ts

@Delete(':id')
  async remove(@Param('id') id: number): Promise<Property> {
    return this.propertiesService.remove(id);
  }

And then after running npm run test

All test are passed

Mmmmmm

We are missing our last part, adding swagger to see our project like this:

that is one task for you...

I will share the final version on my github of the project and also the third part with each step of this tutorial.

I enjoyed a lot to do this tutorial, the TDD approach is a way of programming and it has a lot of benefits (also some cons), but it is one of the best way to have your project always ready to run with no problems!!!

See you Coders, if this post is useful for you, please like and share it! :)

Github Last Part:
https://github.com/joeaspiazudeveloper/nestjs-houselocation-tdd/tree/final-part-removeRest

Github Completed CRUD properties with Swagger
https://github.com/joeaspiazudeveloper/properties-api-nestjs

Create API with NestJS using TDD approach Part two

joedev090 — Fri, 01 Aug 2025 17:31:38 +0000

Hey Coders :)

We continue with the second part of this project using NestJS.

These are some concepts we were checking in the first part.

Core Concepts of TDD

Write a Failing Test:
The first step in the TDD cycle is to write a test for a small piece of functionality that you want to implement
Write Minimal Code to Pass the Test:
The next step is to write the minimal amount of code necessary to make the test pass
Refactor the Code:
Once the test is passing, the final step is to refactor the code to improve its structure and readability.

This cycle, often referred to as "Red-Green-Refactor," ensures that you always have a working version of your code and that all parts of your codebase are covered by tests.

Sooo, let's create the next test case for create property.

In properties/test/properties.service.spec.ts add this code:

describe('create', () => {
    it('should successfully insert a property', async () => {
      const createPropertyDto: CreatePropertyDto = {
        name: 'New Property',
        description: 'New Description',
        location: 'New Location',
        imageUrl: 'http://example.com/image.jpg',
        unitsAvailable: 5,
        hasWifi: true,
        hasLaundry: false,
      };

      const result = await service.create(createPropertyDto);
      expect(result).toBeDefined();
      expect(result.name).toEqual(createPropertyDto.name);
      expect(repository.save).toHaveBeenCalledWith(createPropertyDto);
    });
  });

You should see some errors, no worries!

We have to create a dto for createPropertyDTO, so let's do that.

First install this dependency with this command:

npm i class-validator

Create a new file in dto/create-property-dto.ts and add this code:

import { IsString, IsNumber, IsBoolean } from 'class-validator';

export class CreatePropertyDto {
  @IsString()
  name: string;

  @IsString()
  description: string;

  @IsString()
  location: string;

  @IsString()
  imageUrl: string;

  @IsNumber()
  unitsAvailable: number;

  @IsBoolean()
  hasWifi: boolean;

  @IsBoolean()
  hasLaundry: boolean;
}

Save the changes and run the tests with

npm run test

And you will have the error about the create function in the service. That's fine!!

Let's go to properties.service.ts and add this code at the end:

create(createPropertyDto: CreatePropertyDto): Promise<Property> {
        const newProperty = this.propertiesRepository.create(createPropertyDto);
        return this.propertiesRepository.save(newProperty);
    }

Then let's run the tests again

npm run test

I can see other error, and it was about the mockImplementation of findOne, let's add this code in properties.service.spec.ts, replace the beforeEach

beforeEach(async () => {
    const mockRepository = {
      find: jest.fn().mockResolvedValue([]),
      findOne: jest.fn().mockImplementation((options) =>
        options.where.id === 999
          ? Promise.resolve(null)
          : Promise.resolve({
              id: 1,
              name: 'Test Property',
              description: 'Test Description',
              location: 'Test Location',
              imageUrl: 'http://example.com/image.jpg',
              unitsAvailable: 5,
              hasWifi: true,
              hasLaundry: false,
            }),
      ),
      create: jest.fn().mockImplementation((dto) => dto),
      save: jest
        .fn()
        .mockImplementation((property) =>
          Promise.resolve({ id: 1, ...property }),
        ),
    };

    const module: TestingModule = await Test.createTestingModule({
      providers: [
        PropertiesService,
        {
          provide: getRepositoryToken(Property),
          useValue: mockRepository,
        },
      ],
    }).compile();

    service = module.get<PropertiesService>(PropertiesService);
    repository = module.get<Repository<Property>>(getRepositoryToken(Property));
  });

Finally if you run again the tests, it should be passed!

The next step is to implement the Update funcionality...

As we expect, create the test for the update in src/properties/test/properties.service.spec.ts

// describe the update
  describe('update', () => {
    it('should update a property', async () => {
      const updatePropertyDto: UpdatePropertyDto = {
        name: 'Updated Property',
      };

      const mockProperty = new Property();
      mockProperty.id = 1;
      mockProperty.name = 'Acme Fresh Start Housing';

      jest.spyOn(repository, 'findOne').mockResolvedValue(mockProperty);
      jest.spyOn(repository, 'save').mockResolvedValue({ ...mockProperty, ...updatePropertyDto });

      const result = await service.update(1, updatePropertyDto);
      expect(result.name).toEqual(updatePropertyDto.name);
    });
  });

Then we run the command
npm run test

And it will fails because of the missing function.

Then let's create the function update in the service, but before doing it, we have to install a dependency and create a new file.

Run the command:
npm i @nestjs/mapped-types

After this let's create a new dtos
src/properties/dto/update-property.dto.ts with this code:

import { PartialType } from '@nestjs/mapped-types';
import { CreatePropertyDto } from './create-property.dto';

export class UpdatePropertyDto extends PartialType(CreatePropertyDto) {}

And the final step for update, let's add the function in the service src/properties/properties.service.ts

async update(id: number, updatePropertyDto: UpdatePropertyDto): Promise<Property> {
        const property = await this.findOne(id);
        Object.assign(property, updatePropertyDto);
        return this.propertiesRepository.save(property);
    }

Also let's add this function at the top

async findOne(id: number): Promise<Property> {
        const property = await this.propertiesRepository.findOne({ where: { id } });
        if (!property) {
        throw new NotFoundException(`Property with ID ${id} not found.`);
        }
        return property;
    }

The FindOne is used in the update function.

Finally let's run the tests and it should pass.

After these steps we have implemented the create and update functionality for the service in our nestJS project.

The next step will have similar approach, creating first the tests and then create the function, but we will focus on the controller.

Go to src/properties/test/properties.controller.spec.ts

In this case we will add the tests for creating property

describe('create', () => {
    it('should create a property', async () => {
      const createPropertyDto: CreatePropertyDto = {
        name: 'New Property',
        description: 'New Description',
        location: 'New Location',
        imageUrl: 'http://example.com/image.jpg',
        unitsAvailable: 5,
        hasWifi: true,
        hasLaundry: false,

      };

      const result = await controller.create(createPropertyDto);
      expect(result).toBeDefined();
      expect(result.name).toEqual(createPropertyDto.name);
      expect(service.create).toHaveBeenCalledWith(createPropertyDto);
    })
  })

Also we have to add some additional code in this file:

The main describe is edited with findAll and create in the mockPropertiesService

describe('PropertiesController', () => {
  let controller: PropertiesController;
  let service: PropertiesService;

  beforeEach(async () => {
    const mockPropertiesService = {
      findAll: jest.fn().mockResolvedValue([]),
      create: jest.fn().mockImplementation((createPropertyDto) =>
        Promise.resolve({ id: Date.now(), ...createPropertyDto })
      ),
    };

    const module: TestingModule = await Test.createTestingModule({
      controllers: [PropertiesController],
      providers: [
        {
          provide: PropertiesService,
          useValue: mockPropertiesService, // Use the mock service with the create method
        },
      ],
    }).compile();

    controller = module.get<PropertiesController>(PropertiesController);
    service = module.get<PropertiesService>(PropertiesService);
  });

If you can see any other issue, feel free to check the repository code on github link at the end of the post.

As part of TDD we run the tests and it will fail.

npm run test

We are missing the functionality of create and findOne

Let's add the next code in
src/properties/properties.controller.ts

@Get(':id')
    findOne(@Param('id') id: number): Promise<Property> {
        return this.propertiesService.findOne(id);
    }

    @Post()
    create(@Body() createPropertyDto: CreatePropertyDto): Promise<Property> {
        return this.propertiesService.create(createPropertyDto);
    }

Please the imports necessary to prevent errors, Here we have the import section of this file

import { Body, Controller, Get, Param, Post } from '@nestjs/common';
import { PropertiesService } from './properties.service';
import { Property } from './entities/property.entity';
import { CreatePropertyDto } from './dto/create-property.dto';

After adding the functionality in property service of create and findOne

We will run the tests

npm run test

and Yeyyyy!! it should work passed all.

Let's apply this same approach with the update function to the controller.

First let's create the minimal tests in properties.controller.spec.ts

// update
  describe('update', () => {
    it('should update a property', async () => {
      const updatePropertyDto: UpdatePropertyDto = {
        name: 'Updated Property',
      };

      const result = await controller.update(1, updatePropertyDto);
      expect(result).toBeDefined();
      expect(result.id).toEqual(1);
      expect(result.name).toEqual(updatePropertyDto.name);
      expect(service.update).toHaveBeenCalledWith(1, updatePropertyDto);
    });
  });

Also we have to add in the beforeEach the update parameter in the mockedPropertiesService, adding this code

beforeEach(async () => {
    const mockPropertiesService = {
      findAll: jest.fn().mockResolvedValue([]),
      create: jest.fn().mockImplementation((createPropertyDto) =>
        Promise.resolve({ id: Date.now(), ...createPropertyDto })
      ),
      update: jest.fn().mockImplementation((id: number, updatePropertyDto: UpdatePropertyDto) =>
        Promise.resolve({ id, ...updatePropertyDto }),
      ),
    };

Run the tests,

npm run test

And then we have to add in the controller the update function.

@Put(':id')
  async update(
    @Param('id') id: number,
    @Body() updatePropertyDto: UpdatePropertyDto,
  ): Promise<Property> {
    return this.propertiesService.update(id, updatePropertyDto);
  }

Don't forget to add the necessary imports and if you have some issue, please check the repository on my github.

After we add the update funcion, we should run the tests again

npm run test

And there you go

You should see a screen similar to this!!

It has been a large article, I know, it could be tedious at the beginning but Believe me!! Let's program with this approach and you have the advantage as software engineer!!

See you coders.

This is the link for the repositoy of this second part!!

https://github.com/joeaspiazudeveloper/nestjs-houselocation-tdd/tree/second-part-implementRestFuncTdd

And keep in touch, because in the last part we will finish adding the remove functionality and also we will learn how to add swagger in our nestjs app!!

Chaooooo coders!

Create API with NestJS with TDD approach part one

joedev090 — Mon, 28 Jul 2025 18:34:25 +0000

Hey Coders!!!

A lot of time ago, here we have a new article with an incredible approach from testing.

Let's begin!!

What is Testing?

Testing is a crucial part of the software development process that ensures your code works as intended. It helps catch bugs early, reduces development costs, and improves software quality. There are two main types of testing:

Manual Testing: This involves manually executing test cases without the use of automation tools. It can be time-consuming and is often used for exploratory testing.

Automated Testing: This involves writing scripts or using tools to automatically execute tests. Automated tests can be run frequently and consistently, making them ideal for regression testing.

The next step is introducing to Unit Testing.

What is Unit Testing??

Unit testing is a level of software testing where individual components of a software are tested.

The purpose is to validate that each unit of the software performs as designed. A unit is the smallest testable part of any software. It usually has one or a few inputs and usually a single output.

And now the best part...

You will know how powerful is this concept and I can say this way of programming!!

Introduction to TDD

Test-Driven Development (TDD) is a software development process that relies on the repetition of a very short development cycle.

The cycle involves writing a test for a new function before writing the function itself.

The goal of TDD is to write clean code that works, and it achieves this by ensuring that the code is thoroughly tested.

The TDD Cycle

The TDD cycle can be described as follows:

Write a Failing Test: Start by writing a test for a small piece of functionality that you want to implement. This test should fail initially because the functionality isn't implemented yet.
Write Minimal Code to Pass the Test: Write the minimal amount of code necessary to make the test pass. The goal here is not to write perfect code but to get the test to pass.
Refactor the Code: Once the test is passing, refactor the code to improve its structure and readability. Ensure that the tests still pass after refactoring.

This cycle is often referred to as

"Red-Green-Refactor":

Red: The test fails.
Green: The test passes.
Refactor: Improve the code without breaking the tests.

I know that the theory sometimes is boring, but it is necessary to have the conext of our next project!!

Let's begin with the practice....

Creating a Web API crud with Nestjs using TDD way.

Install NestJS(mandatory have installed latest version of nodejs)

npm install -g @nestjs/cli

Create a new Nestjs project

nest new properties-api
cd properties-api

Then we will install the dependencies for TypeORM and SQLite

npm install @nestjs/typeorm typeorm sqlite3

The next step is configured TypeORM in your app.module.ts file to use SQLite

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'sqlite',
      database: 'db.sqlite',
      entities: [__dirname + '/**/*.entity{.ts,.js}'],
      synchronize: true,
    }),
  ],
})
export class AppModule {}

Then use the Nest CLI to generate a module, service, and controller for managing properties.

nest generate module properties
nest generate service properties
nest generate controller properties

Go ahead, the important part is beginning!!

Create the property entity in properties/entities/property.entity.ts

// src/properties/entities/property.entity.ts
import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';

@Entity()
export class Property {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @Column()
  description: string;

  @Column()
  location: string;

  @Column()
  imageUrl: string;

  @Column()
  unitsAvailable: number;

  @Column({ default: false })
  hasWifi: boolean;

  @Column({ default: false })
  hasLaundry: boolean;
}

In this case, I will create a test folder for the Test file of the service.

You can do it with these lines in your terminal.

mkdir -p src/properties/__test__
touch src/properties/__test__/properties.service.spec.ts

And the magin begins now!!

Let's write a failing Test for findAll in
src/properties/test/properties.service.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { PropertiesService } from '../properties.service';
import { Property } from '../entities/property.entity';
import { getRepositoryToken } from '@nestjs/typeorm';
import { Repository } from 'typeorm';

describe('PropertiesService', () => {
  let service: PropertiesService;
  let repository: Repository<Property>;

  beforeEach(async () => {
    const mockRepository = {
      find: jest.fn().mockResolvedValue([]),
    };

    const module: TestingModule = await Test.createTestingModule({
      providers: [
        PropertiesService,
        {
          provide: getRepositoryToken(Property),
          useValue: mockRepository,
        },
      ],
    }).compile();

    service = module.get<PropertiesService>(PropertiesService);
    repository = module.get<Repository<Property>>(getRepositoryToken(Property));
  });

  it('should be defined', () => {
    expect(service).toBeDefined();
  });

  describe('findAll', () => {
    it('should return an array of properties', async () => {
      const result = await service.findAll();
      expect(result).toEqual([]);
    });
  });
});

We are creating firstly the test before create the findAll function in the service and then run

npm run test

This test will fail, and the reason is because we need to create the function in the service.

So Implement the findAll Method in the Service:

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Property } from './entities/property.entity';

@Injectable()
export class PropertiesService {
  constructor(
    @InjectRepository(Property)
    private propertiesRepository: Repository<Property>,
  ) {}

  findAll(): Promise<Property[]> {
    return this.propertiesRepository.find();
  }
}

This is the way we should do using TDD.
First we implement a basic using testing case and then we implement the function or the functionality!!!

Let's repeat the process for the Property controller

Create the test file

touch src/properties/__test__/properties.controller.spec.ts

Write a failing testing for the controller

import { Test, TestingModule } from '@nestjs/testing';
import { PropertiesController } from '../properties.controller';
import { PropertiesService } from '../properties.service';

describe('PropertiesController', () => {
  let controller: PropertiesController;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      controllers: [PropertiesController],
      providers: [
        {
          provide: PropertiesService,
          useValue: {
            findAll: jest.fn().mockResolvedValue([]),
          },
        },
      ],
    }).compile();

    controller = module.get<PropertiesController>(PropertiesController);
  });

  it('should be defined', () => {
    expect(controller).toBeDefined();
  });

  describe('findAll', () => {
    it('should return an array of properties', async () => {
      const result = await controller.findAll();
      expect(result).toEqual([]);
    });
  });
});

Then execute:

npm run test

It will fail!!

And then, we implement the controller function in src/properties/properties.controller.ts

import { Controller, Get } from '@nestjs/common';
import { PropertiesService } from './properties.service';
import { Property } from './entities/property.entity';

@Controller('properties')
export class PropertiesController {
  constructor(private readonly propertiesService: PropertiesService) {}

  @Get()
  findAll(): Promise<Property[]> {
    return this.propertiesService.findAll();
  }
}

After these steps we can repeat the testing with

npm run test
It should pass all tests

And be sure to have the properties.module.ts with this code:

import { Module } from '@nestjs/common';
import { PropertiesService } from './properties.service';
import { PropertiesController } from './properties.controller';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Property } from './entities/property.entity';

@Module({
  imports: [TypeOrmModule.forFeature([Property])],
  providers: [PropertiesService],
  controllers: [PropertiesController]
})
export class PropertiesModule {}

Finally start your nestJs Application

npm run start
And there you go....

The first part of our NestJs app using TDD.

You can test this project with Postman or in your browser.

http://localhost:3000/properties

You can see an empty [] array!!

Keep in touch to see the next part of this project, I will add the github repository where you can see the entire code I explained.

Let me know if you have any suggestions or questions, please!!

Keep coding! :)

https://github.com/joeaspiazudeveloper/nestjs-houselocation-tdd

10 Errores mas comunes en React para desarrolladores junior y semi-senior

joedev090 — Tue, 20 May 2025 18:33:35 +0000

Holaaa Coders!! A los tiempos... :)

Esta vez les traigo un post interesante!!

Muchos desarrolladores con experiencia pensamos que estamos libres de cometer errores comunes en el mundo de la programacion.

React es una libreria UI poderosa y popular para crear interfaces de usuario, veamos que errores nos pueden ayudar a evitar problemas de performance, mantenimiento y experiencia de usuario.

1️⃣. Olvidar usar keys en las listas

Al renderizar listas, los keys ayudan a React a identificar que elementos han cambiado, mejorando el rendimiento y evitando comportamientos inesperados en la interfaz de usuario.

❌ Incorrecto

{items.map((item) => <ItemComponent item={item} />)}

✅ Correcto

{items.map((item) => <ItemComponent key={item.id} item={item} />)}

💡 Por que es importante?
React necesita claves para actualizar el DOM de manera eficiente cuando los elementos cambian.
Usar claves únicas y estables (como IDs) asegura una reconciliación adecuada.

2️⃣. Usar mucho useState en vez de declarar variables normalmente

El estado debe almacenar solo valores esenciales. Si un valor puede derivarse de las props o del estado existente, evita almacenarlo por separado.

❌ Incorrecto

const [fullName, setFullName] = useState(${firstName} ${lastName});

✅ Correcto

const fullName = ${firstName} ${lastName};

💡 Por que es importante?
Esto reduce las renderizaciones innecesarios y mantiene el estado mínimo y predecible.

3️⃣. No liberar los effects en UseEffect()

Olvidar limpiar los effects puede llevar a fugas de memoria.

❌ Incorrecto

useEffect(() => { window.addEventListener("resize", handleResize); }, []);

✅ Correcto

useEffect(() => { window.addEventListener("resize", handleResize); return () => window.removeEventListener("resize", handleResize); }, []);

💡 Por que es importante?
previene que los listener de eventos innecesarios se acumulen con el tiempo.

4️⃣. Usar Funciones Inline en JSX Innecesariamente

Las funciones inline causan re-renders innecesarios porque se crea una nueva función en cada renderizado.

❌ Incorrecto

<button onClick={() => handleClick(id)}>Click me</button>

✅ Correcto

const handleClickWithId = useCallback(() => handleClick(id), [id]); <button onClick={handleClickWithId}>Click me</button>

💡 Por que es importante?
useCallback asegura que la función solo se vuelva a crear cuando las dependencias cambien, reduciendo la sobrecarga de rendimiento.

5️⃣. No usar lazy loading para componentes grandes

El lazy loading mejora los tiempos de carga inicial al dividir el código.

❌ Incorrecto

import HeavyComponent from "./HeavyComponent";

✅ Correcto

const HeavyComponent = React.lazy(() => import("./HeavyComponent"));

💡 Por que es importante?

React.lazy carga los componentes solo cuando son necesarios, reduciendo el tamaño inicial del paquete de JavaScript.

Conclusion:

Evitar estos errores comunes en React puede marcar una gran diferencia en el rendimiento y la mantenibilidad de tus aplicaciones.

Al seguir las mejores prácticas, como usar claves únicas en listas, evitar el uso excesivo de estado, limpiar efectos en useEffect, evitar funciones inline innecesarias y utilizar carga perezosa para componentes grandes, puedes mejorar significativamente la calidad de tu código.

Esta es la primera parte de los errores a evitar en React.

No te pierdas la segunda parte!!

Espero te haya gustado este post, no olvides darle like o compartirlo!

Hasta pronto Coders!