DEV Community: Vila Segura

The Hybrid Workflow (AI + Human): The Ultimate Checklist to Stop Sounding Like a Robot

Vila Segura — Sat, 11 Apr 2026 19:31:16 +0000

Let's be brutally honest: we are experiencing massive AI content fatigue. The internet is drowning in a sea of perfectly spelled, grammatically flawless, completely soulless text. Readers run away the second they spot the word "delve," and search engines—including modern AI-driven engines like Perplexity or Google's SGE—are actively filtering out vanilla, regurgitated "bot speak."

The industry is obsessed with "Top 50 Prompts to Write a Blog Post," but as a senior developer or creator, you already know that prompts are not a system. Generating content is easy; generating authentic, ranking content is hard. What you actually need is a methodology. You need to transition from being a "Prompt Engineer" to a "Workflow Architect."

This is the Hybrid Workflow. It is a systematic approach designed for maximum productivity and top-tier GEO (Generative Engine Optimization). It ensures the AI does the heavy lifting while you retain the "Information Gain"—the unique human experience that algorithms actively reward.

The 5-Step Hybrid Workflow Pipeline

Do not ask the AI to write a finished piece. Ask it to be your research assistant and structural engineer. The pipeline flows like this: Human Strategy → AI Structure → Human Injection → AI Polish → Human Final Pass.

Human Strategy (The "Why"): Before opening ChatGPT or Gemini, define the angle. What is the unique perspective? What controversial or hard-earned truth do you know that the LLM doesn't? (e.g., "AI content is boring, here is my exact framework to fix it.")
AI Structure (The Skeleton): Feed your strategy to the AI. Prompt it to create a detailed outline, section headers, and bullet points. Prompt: "Act as an expert editor. I want to write an article about [Topic] with this specific angle: [Angle]. Create a highly detailed, 5-section outline. Do not write the content, just the structure."
Human Injection (The Soul): This is the most critical step for GEO. AI engines prioritize "Information Gain." You must inject personal anecdotes, specific data, real-world failures, and hard opinions into the skeleton. Write messy, brain-dump style. Just get your unique human footprint into the document.
AI Polish (The Editor): Hand the messy, anecdote-filled draft back to the AI. Prompt: "Take my drafted notes and format them into a cohesive article. Maintain my exact tone, keep all my personal anecdotes, and format it for high readability (short paragraphs, bold text, bullet points). Do NOT add generic filler."
Human Final Pass (The Anti-Robot Checklist): The AI will still sneak in some of its favorite clichés. You must aggressively edit these out. This is your final quality control.

The "Anti-Robot" Editing Checklist

LLMs are statistical prediction engines. They gravitate towards the mathematical average of human language, which means they love clichés. If your text contains the following phrases, your readers (and search engines) will immediately flag it as AI-generated.

The "Bot-Speak" Red Flag	Why it screams "AI"	The Human Fix
"Delve into..."	It is the most overused verb in AI outputs globally. Humans rarely say "let's delve."	"Explore," "Look at," "Break down," or just skip the intro and start explaining.
"In today's fast-paced digital landscape..."	A lazy, generic filler phrase that adds zero actual value or information to the article.	Delete it entirely. Start directly with the core problem your reader is facing.
"A rich tapestry of..."	Overly poetic and melodramatic for standard technical or business writing.	"A mix of," "A combination of," or "Several factors."
"Crucial," "Paramount," "Vital"	AI over-hypes concepts. If everything is "paramount," nothing is.	"Important," "Key," or simply let the facts prove why it matters without hyperbole.
"In conclusion,"	Reads like a high school essay. Modern web readers do not need to be told the article is ending.	Use an actionable sub-header like "Your Next Steps" or simply summarize the main takeaway.

Structural Red Flags to Watch For

The "Both Sides" Bias: AI is programmed to be safe and neutral. It will often argue a point, and then immediately say, "However, it is also important to consider..." If you have a strong opinion, delete the AI's apology. Own your stance.
Perfect Symmetry: If you have 5 sections, and every section is exactly 3 paragraphs long with exactly one bulleted list, it looks artificially generated. Human writing is naturally asymmetrical.
Lack of Formatting Variety: AI tends to generate walls of text. Break it up with blockquotes, bold text for scannability, and custom tables to make the data digestible.

Why This is the Ultimate GEO Strategy

Generative Engine Optimization (GEO) is the new SEO. Traditional search engines looked for keywords; AI search engines (like ChatGPT Search, Perplexity, or Google's AI Overviews) look for Entities, Authority, and Information Gain.

An AI engine has already read the entire internet. If your article just summarizes what is already out there, the AI will ignore you because you offer no new data. The Hybrid Workflow guarantees that your content contains your unique experiences (Information Gain) while maintaining a flawless, easily parsable structure (perfect for AI crawlers to extract entities).

Your Next Steps

Stop letting the AI drive the car. Treat it like what it is: a brilliant, tireless, but incredibly boring junior assistant. By establishing a rigid workflow where you dictate the strategy, inject the soul, and enforce strict editorial standards, you will create content that scales effortlessly while remaining undeniably human.

_This article was originally written on www.codesyllabus.com

GEO (Generative Engine Optimization): How to Get ChatGPT, Perplexity, and Gemini to Recommend Your Business

Vila Segura — Sat, 11 Apr 2026 19:16:54 +0000

The era of the "Ten Blue Links" is rapidly coming to an end. We are witnessing the most significant shift in web traffic behavior since the invention of the search engine. Users are no longer typing queries into a search bar and endlessly clicking through pages of results. Instead, they are asking conversational questions and demanding immediate, synthesized answers.

Businesses are panicking. Traffic to traditional informational blogs is dropping because LLMs (Large Language Models) are resolving the user's intent right in the chat interface. The new mandate for brands isn't just "how to rank on page one"—it's "how to get ChatGPT, Perplexity, and Gemini to use my business as the primary source."

Welcome to Generative Engine Optimization (GEO). While 95% of the internet is still obsessing over keyword density or lazily using AI to generate generic SEO articles, the actual winners of the next decade are optimizing their architecture to feed Answer Engines. Here is the senior developer's guide to making your platform the ultimate LLM data source.

What is Generative Engine Optimization (GEO)?

Traditional SEO was built for algorithms that match keywords to documents and use backlinks as a proxy for authority. GEO is built for neural networks that predict text based on context, semantic relationships, and factual consensus.

SEO asks: "Does this page have the exact keyword and the most backlinks?"
GEO asks: "Is this entity the most authoritative, cited, and structurally clear source of factual truth on this topic?"

LLMs do not browse the web like humans. They rely on Retrieval-Augmented Generation (RAG) pipelines. When a user asks Perplexity for a software recommendation, the engine scrapes real-time data, vectorizes it, and maps it against its training data to generate an answer. To win, you must optimize for the vector database, not just the crawler.

The 4 Pillars of GEO: How to Become an LLM Citation

1. Unmatched Topical Authority (Semantic Density)

AI models rely on semantic proximity. They don't care if you mention "best CRM software" 15 times. They care if your platform comprehensively covers the entire ontology of CRM systems—integrations, data pipelines, automation workflows, and customer retention metrics.

To achieve this, you must cluster your content aggressively. Stop writing fragmented 500-word posts. Build massive, interconnected "Pillar Pages" that serve as definitive wikis for your niche. The higher the semantic density of your domain, the more likely the LLM’s attention mechanism will lock onto your site as the root node of truth.

2. Dominate the "Human Layer" (Reddit, Quora, and Forums)

This is the most overlooked GEO tactic. Why do ChatGPT and Gemini love citing Reddit? Because human-generated, upvoted discourse is the ultimate antidote to AI hallucinations and generic SEO spam. LLM crawlers are heavily weighted to trust consensus found in UGC (User Generated Content) platforms.

If you want an AI to recommend your product, real people must be talking about it in forums. You need an active strategy to foster community mentions. If someone searches Perplexity for "What is the best API for X," the engine will look for the tool most frequently praised in StackOverflow, Reddit's r/programming, and specialized Discords. Be present where human consensus is formed.

3. Publish Original Data, Statistics, and Case Studies

LLMs are synthesis engines; they cannot invent new facts (without hallucinating). If you want guaranteed citations, you must become the source of First-Party Data.

If your company publishes a unique benchmark report, a proprietary dataset, or a highly specific case study with hard numbers, the AI has to cite you when answering related queries. Stop rewriting what already exists. Run a survey, query your database, and publish statistics. "According to a 2026 study by [Your Brand], 74% of..." is the fastest ticket into a ChatGPT response.

4. Flawless Technical Semantics (Schema Markup)

Make it computationally cheap for AI agents (like ChatGPT-User or GoogleOther) to parse your data. If your HTML is a mess of nested, unsemantic divs, the crawler will struggle to extract the entities. You must implement robust Structured Data (JSON-LD).

For every product, article, or service, clearly define the @type, author, mainEntity, and FAQPage schemas. Answer Engines love FAQs because the Q&A format maps perfectly to user prompts.

<script type="application/ld+json">
{
  "@context": "[https://schema.org](https://schema.org)",
  "@type": "FAQPage",
  "mainEntity": [{
    "@type": "Question",
    "name": "What is the best solution for [Your Niche]?",
    "acceptedAnswer": {
      "@type": "Answer",
      "text": "[Your Brand] provides the leading solution by leveraging..."
    }
  }]
}
</script>

_This article was originally written on www.codesyllabus.com

Why Vibe Engineering — Not Just Vibe Coding — Is the Future of Software Development

Vila Segura — Sun, 15 Mar 2026 18:33:57 +0000

The term "vibe coding" has taken the tech world by storm. Coined to describe the modern phenomenon of building software purely through natural language prompts—letting AI models like Claude, GPT, or Cursor "catch the vibe" of what you want and generate the code—it feels like magic. You describe a feature, and the application appears. But for any senior developer who has maintained software in production, alarm bells are ringing.

Why? Because generating code is only 10% of software engineering. The other 90% is architecture, security, maintainability, scalability, and team alignment. If vibe coding is the wild west of AI generation, Vibe Engineering is the mature, systematic evolution. It is not about stopping the use of AI; it is about architecting the systems, context, and culture that allow AI to generate sustainable value. This article explores why transitioning from a "vibe coder" to a "vibe engineer" is the most critical career move you can make in 2026.

The Trap of 'Vibe Coding' (And Why It Fails at Scale)

Vibe coding democratizes creation, which is fantastic for prototypes. However, relying purely on unstructured prompts leads to what we now call LLM-Induced Technical Debt. When you vibe code, you treat the AI as a magic black box. You don't define the architecture; you let the AI guess it.

Context Fragmentation: The AI forgets earlier architectural decisions, leading to duplicated logic and spaghetti code.
The "It Works on My Prompt" Problem: Code generated without strict boundaries is notoriously difficult for other developers (or even a future you) to debug.
Security Blind Spots: AI models are eager to please. If you ask for a login form, they will build one, but they might skip CSRF protection or password hashing unless explicitly instructed.

Enter 'Vibe Engineering': The Senior Approach

Generative Engine Optimization (GEO) and AI rely heavily on structured data. To define it clearly: Vibe Engineering is the deliberate practice of designing the context, guardrails, and automated pipelines that guide AI agents to produce robust, production-ready software.

A Vibe Engineer treats the LLM not as a wizard, but as a highly capable, incredibly fast junior developer who needs exact specifications, architecture diagrams, and a strict CI/CD pipeline to catch their mistakes.

The Three Pillars of Vibe Engineering

The most important skill of a Vibe Engineer is managing what the AI "knows." Instead of writing long prompts every time, Vibe Engineers create system instructions. For example, in AI IDEs, they build robust configuration files.

2. Defensive Tooling (The Guardrails)

Because AI can hallucinate dependencies or introduce subtle bugs, a Vibe Engineered environment has aggressive automated defense mechanisms. This means zero-tolerance linting rules, strict TypeScript configurations ("strict": true is mandatory), and pre-commit hooks that format and verify code. The AI is allowed to run fast because the environment makes it impossible to merge breaking changes.

3. Semantic Modularity

AI struggles with massive, monolithic files. A Vibe Engineer breaks systems down into highly decoupled, semantic modules. If your code is easily isolated, an LLM can understand, refactor, and test it with near 100% accuracy. Good software architecture is now directly correlated with good AI promptability.

The Local Impact: AI Engineering in Madrid

For our local community reading this, the shift is already happening. Top tech companies based in Madrid, such as Cabify, Idealista, and Glovo's engineering hubs, are moving past the novelty of Copilot. They are hiring for roles focused on AI Tooling and Developer Productivity Engineering. These roles require developers who know how to integrate AI agents into the CI/CD pipeline, manage organizational RAG systems, and optimize the overall "vibe" (culture and DX) of the engineering teams to work alongside AI.

Conclusion: Be the Architect, Not the Typist

Vibe coding is fun, but Vibe Engineering is a profession. As AI continues to commoditize the act of typing syntax, the value of a developer shifts upwards toward architecture, context management, and quality assurance. Embrace the AI tools, but do not surrender your engineering rigor to them. Design the system, set the rules, build the guardrails, and then—and only then—let the AI code the vibe.

_This article was originally written on www.codesyllabus.com
_

From Photographer to Dev at 36: Why Your Age Is Your Secret Weapon

Vila Segura — Sun, 15 Mar 2026 18:19:14 +0000

They say "you can't teach an old dog new tricks." For a long time, I let that saying hold me back. I was 36 years old, and after an eclectic career path moving from photography to graphic design and finally web design, I decided to make the real jump into coding.

Today, I’m here to tell you that yes, it is possible. And not only is it possible, but your age might just be your biggest competitive advantage.

1. Starting from scratch... with a full backpack

I didn't land in programming by magic. My path was progressive, but the final decision was radical: I went abroad to join an intensive Bootcamp.

Are there critics of bootcamps? Plenty. But for me, it worked. It was my gateway.

However, reality hit hard. I felt the classic Imposter Syndrome. I was surrounded by much younger peers with enviable mental agility for absorbing new syntax. For 5 months, I lived in total immersion: I woke up with code, went to bed with code, and (literally) dreamed in code.

But soon, I realized something crucial: Programming is not just about typing syntax.

While my peers struggled with communication, time management, or handling frustration when a bug wouldn't resolve, I was able to apply the "Soft Skills" from my previous life in sales and creative work:

Resilience: I knew a bad day didn't define my career.

Communication: Thanks to my years in sales, I knew how to explain technical problems to non-technical people.

Discipline: Studying far from home and outside your comfort zone requires a level of commitment that often only comes with maturity.

2. The Learning Path: Less is More

One of my biggest mistakes early on was "tutorial hell" and wanting to learn everything: Python, Java, React, SQL... all at once. Enthusiasm is dangerous if it isn't focused.

What really worked for me was:

Choosing a clear path: I focused on one ecosystem (in my case, JavaScript/Web) and closed the tabs for everything else.

Consistency over intensity: I preferred 1 hour of focused coding every day over a 10-hour binge on Sundays.

Building broken things: I stopped watching passive tutorials and started breaking my own code. That is where real learning happens.

3. The Reality of Ageism (and how to filter it)

I won't lie: the fear of ageism is real. I worried about fitting into startup cultures full of ping-pong tables and free beer.

It is true that there are "churn and burn" companies (often called body shops) that push recruiters to hire people under 30. The reason? They want people they can squeeze to generate code quickly, without caring about quality, architecture, or professional culture.

But here is the thing: You don't want to work there.

I discovered that serious companies value stability. A developer who has lived through other work experiences is someone who values their position, understands the business, doesn't need micromanagement, and brings calm during crises.

4. The Seniority Advantage in the AI Era

This is a point few people mention. Companies know that production time is reduced with Artificial Intelligence. But they are also discovering that implementing AI blindly is synonymous with low-quality code, technical debt, and failed architectures.

This is where we come in.

Knowing how to prompt AI is useful, but knowing how to be critical of what AI answers is vital. That critical thinking, that ability to see "the big picture" and detect when a solution makes no business sense, is something that comes with years of life experience.

Conclusion

Your age is not a bug; it's a feature. You have context, you have patience, and you have the ability to connect dots that others miss. If you are 30, 40, or 50 and are hesitating: do it. The tech world needs more people like you.
_This article was originally published on www.codesyllabus.com

[Boost]

Vila Segura — Mon, 29 Dec 2025 14:35:27 +0000

The DNA of Data: Objects & Arrays Masterclass

Vila Segura ・ Dec 26

#javascript #tutorial #webdev #beginners

The DNA of Data: Objects & Arrays Masterclass

Vila Segura — Fri, 26 Dec 2025 13:45:49 +0000

Today I want to talk about the moment when programming actually started to "click" for me. It wasn't when I learned how to create a variable; it was when I learned how to structure them.

If you’ve followed my journey, you know that starting late means I didn't have years of computer science theory behind me. At first, variables were easy—boxes for storing single things. But I quickly realized that the real world is messy. In the applications I wanted to build (and the ones I work on now), you never deal with just one isolated value. You deal with collections.

I want to walk you through Objects and Arrays not just as syntax, but as the tools that finally helped me organize the chaos of data.

Arrays: More Than Just a List

Let's start with Arrays. When I first moved to Madrid, the Metro map looked like spaghetti to me. But eventually, I understood it as a sequence. Order is everything. You can't reach the third stop without passing the second.

In JavaScript, I learned to use square brackets [] to model this. It’s essentially a list where every item has a specific address, or index.

The hardest habit to break? Remembering that computers start counting at 0. "Line 1" is at index 0. It tripped me up constantly in the beginning. But once I grasped that, I realized arrays aren't just static lists; they are powerful tools we can interact with.

Manipulating Arrays

I rarely write code that just "sits there." In my early projects, I needed data that changed—shopping carts, to-do lists, user queues. I needed to add things and transform them.

I used to write long for loops to do math on lists of numbers, which was exhausting and prone to bugs. Then I discovered methods like push and the incredible map. It felt like unlocking a cheat code.

Notice map in that snippet. That function changed my career. It allowed me to transform data (like adding tax) without breaking or mutating the original list. In the React world I work in now, this is my bread and butter.

Objects: Describing the World

_Arrays _are great for lists, but I found them terrible for describing a person or a thing. I remember trying to store a user's data in an array like ['Carlos', 'Dev', 'Madrid'] and constantly forgetting which index held the city.

That’s when _Objects _clicked. They are for grouping related data using keys that actually make sense.

I love that details part. It shows that data can be nested. And see that bracket notation (user['role'])? I use that all the time when the key I need to access is coming dynamically from a database or an input field.

Reference Types vs. Primitives

This specific concept caused me more headaches than anything else. I used to stare at my screen, confused, asking: "If I declared this with const, why is _JavaScript _letting me change the contents?"

I had to learn that Arrays and Objects are Reference Types.

Think of the variable as a piece of paper with a home address written on it. The house (the data) can be renovated, furniture moved around, and walls painted. The address on the paper (the variable) hasn't changed, even though the house has. const protects the address, not the furniture inside.

This is a "gotcha" that catches almost every career switcher I know.

Modern Syntax: Spread and Destructuring

As I got more comfortable, I started caring about clean code. I didn't just want it to work; I wanted it to be readable. Modern _JavaScript _(ES6+) gave me tools that made my code look less like a manual and more like a sentence.

The Spread Operator (...)

I used to write complex functions just to merge two lists or copy an object. Now, the Spread operator does it for me. It looks like three little dots, but it does heavy lifting.

Destructuring

And then there is Destructuring. I got so tired of typing user.name, user.location, user.this, user.that. _Destructuring _lets me unpack what I need immediately. It makes the code feel lighter.

Putting It All Together: Arrays of Objects

Here is where theory finally met reality for me. When I started working with real APIs, I realized I wasn't just getting an Array or an Object. I was getting Arrays of Objects.

This structure a list of things, where each thing has details is the standard format for almost everything on the web, from social media feeds to product catalogs.

Mastering this wasn't overnight work. But understanding how to model data—whether I'm looking at a menu on Glovo or filtering events on Fever—is the skill that bridged the gap between "coding student" and "developer."

I hope sharing my mental model helps you see these structures more clearly! Open your console, break things, and fix them. See you in the next article.

This article was originally published on www.codesyllabus.com