DEV Community: Roberto Luna

Building lavanderia-crm — 2026-06-17

Roberto Luna — Thu, 18 Jun 2026 19:36:24 +0000

When I think about what drives me as a developer, it's not just about solving complex technical problems, but also about understanding how those solutions impact people's lives. Recently, I found myself reflecting on a project that's close to my heart - the lavanderia-crm repository. It's a project that started as a simple CRM system for a local laundry business, but over time, it has evolved into a full-fledged platform that explores the intersection of productivity, cybersecurity, and AI. On June 17, 2026, I made a commit that might seem minor at first glance, but it marked a significant shift in how I approach documentation and context within the project.

The problem that led to this commit was a growing sense of disconnection between the codebase and the documentation. As the project grew, it became increasingly difficult to keep the documentation up-to-date, and I found myself spending more time explaining the context to new contributors than actually writing code. The lavanderia-crm repository is hosted on GitHub, and the main branch is also tracked on a ClickUp list for project management. This setup has been working well for the most part, but the lack of clear context in the documentation was starting to become a bottleneck. I needed to find a way to update the documentation in a way that would provide a clear understanding of the project's context without overwhelming new contributors.

The context of this problem is crucial. The lavanderia-crm project is not just a simple CRM system; it's a platform that integrates with various third-party services, uses Docker for containerization, and explores the use of AI for predictive analytics. The project's complexity means that any solution to the documentation problem would need to be robust and scalable. Furthermore, the project's GitHub repository is public, which adds an extra layer of complexity when it comes to cybersecurity. I needed to ensure that any updates to the documentation would not compromise the security of the project or its contributors.

My first approach to solving this problem was to try and update the documentation manually. I spent hours poring over the codebase, trying to identify areas where the documentation was outdated or incomplete. However, this approach quickly proved to be inefficient. The project is large, and updating the documentation manually would have taken weeks, if not months. I needed a more automated solution, one that would allow me to update the documentation quickly and efficiently. That's when I decided to explore the use of AI-powered documentation tools. I spent several days researching different options, from automated documentation generators to AI-powered content creation tools.

The solution I finally settled on was to use a combination of automated documentation tools and manual updates. I used a tool called CLAUDE to generate automated documentation for the project's API endpoints. CLAUDE is a powerful tool that allows you to generate high-quality documentation quickly and efficiently. However, I also knew that automated tools can only go so far. I needed to provide context and explanations for the documentation, which is where the manual updates came in. I spent several hours updating the CLAUDE.md file, adding explanations and context to the automated documentation. The commit I made on June 17, 2026, was the result of this work. The updated CLAUDE.md file now provides a clear understanding of the project's context, including its integration with third-party services and its use of Docker and AI.

One of the key lessons I learned from this experience is the importance of providing clear context in documentation. As developers, we often focus on writing clean, efficient code, but we neglect the documentation. However, documentation is just as important as the code itself. It provides context, explanations, and guidance for other developers who may work on the project in the future. By providing clear context, we can ensure that our projects are maintainable, scalable, and secure. Another lesson I learned is the value of automated tools. While automated tools can't replace human judgment and expertise, they can certainly help with repetitive tasks like documentation generation. By leveraging automated tools, we can free up more time to focus on the complex, creative tasks that require human intervention.

As I look to the future, I know that there's still much work to be done on the lavanderia-crm project. One of the next steps I plan to take is to explore the use of AI-powered content creation tools to generate user documentation. While the CLAUDE tool has been helpful for generating automated documentation for the API endpoints, I need to provide user-friendly documentation for the project's users. I'm excited to see how AI can help with this task, and I'm looking forward to sharing my findings with the community. For now, I'm proud of the progress I've made on the lavanderia-crm project, and I'm grateful for the opportunity to reflect on my experiences as a developer. By sharing my story, I hope to inspire others to prioritize documentation, context, and clarity in their own projects.

The code changes I made to the CLAUDE.md file were significant, and they demonstrate the importance of clear context in documentation. The updated file now includes explanations of the project's integration with third-party services, its use of Docker, and its exploration of AI for predictive analytics. Here's an example of the updated code:

---
## Actualización — Junio 2026
##

This may seem like a simple update, but it marks a significant shift in how I approach documentation and context within the project. By providing clear context, I can ensure that the project is maintainable, scalable, and secure. As I continue to work on the lavanderia-crm project, I'll be sure to prioritize documentation, context, and clarity, and I hope to inspire others to do the same.

In the end, the experience of updating the CLAUDE.md file taught me a valuable lesson about the importance of clear context in documentation. As developers, we must prioritize documentation and provide clear explanations for our code. By doing so, we can ensure that our projects are maintainable, scalable, and secure. I'm excited to see how the lavanderia-crm project will continue to evolve, and I'm looking forward to sharing my experiences with the community. By working together, we can create better documentation, better code, and better projects that benefit everyone involved.

As I reflect on my experience with the lavanderia-crm project, I'm reminded of the importance of perseverance and creativity in software development. The project has been a challenging but rewarding experience, and I'm grateful for the opportunity to work on it. I hope that my story will inspire others to pursue their own passion projects, and to never give up in the face of challenges. With hard work, determination, and a willingness to learn, we can overcome any obstacle and create something truly remarkable.

In conclusion, my experience with the lavanderia-crm project has taught me the importance of clear context in documentation, the value of automated tools, and the need for perseverance and creativity in software development. I hope that my story will inspire others to prioritize documentation, to explore the use of automated tools, and to never give up on their passion projects. By working together, we can create better software, better documentation, and better projects that benefit everyone involved.

The journey of the lavanderia-crm project is far from over, and I'm excited to see what the future holds. I'll continue to work on the project, prioritizing documentation, context, and clarity, and I'll be sure to share my experiences with the community. By doing so, I hope to inspire others to pursue their own passion projects, and to never give up in the face of challenges. With hard work, determination, and a willingness to learn, we can create something truly remarkable, and we can make a positive impact on the world.

As I look back on my experience with the lavanderia-crm project, I'm reminded of the importance of reflection and self-improvement in software development. By reflecting on our experiences, we can identify areas for improvement, and we can develop new skills and strategies to overcome challenges. I hope that my story will inspire others to reflect on their own experiences, and to prioritize self-improvement in their own work. By doing so, we can become better developers, better teammates, and better professionals, and we can make a positive impact on the world.

In the end, the lavanderia-crm project has taught me a valuable lesson about the importance of clear context in documentation, the value of automated tools, and the need for perseverance and creativity in software development. I hope that my story will inspire others to prioritize documentation, to explore the use of automated tools, and to never give up on their passion projects. By working together, we can create better software, better documentation, and better projects that benefit everyone involved.

The future of the lavanderia-crm project is bright, and I'm excited to see what the future holds. I'll continue to work on the project, prioritizing documentation, context, and clarity, and I'll be sure to share my experiences with the community. By doing so, I hope to inspire others to pursue their own passion projects, and to never give up in the face of challenges. With hard work, determination, and a willingness to learn, we can create something truly remarkable, and we can make a positive impact on the world.

As I reflect on my experience with the lavanderia-crm project, I'm reminded of the importance of community and collaboration in software development. The project has been a challenging but rewarding experience, and I'm grateful for the opportunity to work on it. I hope that my story will inspire others to pursue their own passion projects, and to never give up in the face of challenges. By working together, we can create better software, better documentation, and better projects that benefit everyone involved.

As I look to the future, I know that there's still much work to be done on the lavanderia-crm project. I'll continue to work on the project, prioritizing documentation, context, and clarity, and I'll be sure to share my experiences with the community. By doing so, I hope to inspire others to pursue their own passion projects, and to never give up in the face of challenges. With hard work, determination, and a willingness to learn, we can create something truly remarkable, and we can make a positive impact on the world.

As I reflect on my experience with the lavanderia-crm project, I'm reminded of the importance of continuous learning and improvement in software development. The project has been a challenging but rewarding experience, and I'm grateful for the opportunity to work on it. I hope that my story will inspire others to pursue their own passion projects, and to never give up in the face of challenges. By working together, we can create better software, better documentation, and better projects that benefit everyone involved.

By sharing my story, I hope to inspire others to reflect on their own experiences, and to prioritize self-improvement in their own work. By doing so, we can become better developers, better teammates, and better professionals, and we can make a positive impact on the world. The journey of the lavanderia-crm project is far from over, and I'm excited to see what the future holds. I'll continue to work on the project, prioritizing documentation, context, and clarity, and I'll be sure to share my experiences with the community. By doing so, I hope to inspire others to pursue their own passion projects, and to never give up in the face of challenges. With hard work, determination, and a willingness to learn, we can create something truly remarkable, and we can make a positive impact on the world.

Part of my Build in Public series — sharing the real process of building Building Lavandería CRM from Playa del Carmen, México.

Repo: zaerohell/lavanderia-crm · 2026-06-17

#playadev #buildinpublic

Tokenize the topic and remove stopwords

Roberto Luna — Thu, 18 Jun 2026 19:34:54 +0000

When Automation Meets Creativity: My Journey with Content Automation

As a full-stack developer, I've always been fascinated by the intersection of technology and creativity. Recently, I've been working on a project that combines these two interests: automating content generation for my blog and social media channels. The goal is to create a system that can produce high-quality, engaging content without requiring manual intervention. It sounds like a daunting task, but I'm excited to share my journey and the lessons I've learned along the way. The problem that motivated me to start this project was the lack of consistency in my content creation. I would often find myself struggling to come up with new ideas, and even when I did, I would spend hours writing and editing.

The Problem of Inconsistent Content Creation

The problem of inconsistent content creation was not only affecting my blog but also my social media presence. I have a presence on multiple platforms, including Dev.to, Hashnode, and Squad playadev, and I wanted to find a way to automate the process of creating and publishing content across these platforms. I tried using existing tools and services, but they didn't quite meet my needs. I wanted a system that could understand my tone, style, and voice, and produce content that resonated with my audience. I decided to take matters into my own hands and start building a custom solution.

The Context of My Content Automation Project

My content automation project, dubbed "content-automation," is a Python-based system that uses a combination of natural language processing (NLP) and machine learning algorithms to generate content. The system is designed to learn from my existing content and adapt to my writing style over time. I've been working on this project for several weeks now, and I've made significant progress. The system can currently generate content for my blog and social media channels, including Dev.to, Hashnode, and Squad playadev. I've also integrated the system with my ClickUp workflow, which allows me to track and manage my content creation process.

Exploring Different Approaches to Content Automation

When I first started working on the content-automation project, I tried using a simple template-based approach. I created a set of templates for different types of content, such as blog posts and social media updates, and used a templating engine to fill in the blanks. However, this approach quickly became cumbersome and inflexible. I realized that I needed a more dynamic approach that could adapt to my changing needs and writing style. I started exploring different NLP and machine learning libraries, including NLTK, spaCy, and scikit-learn. I also experimented with different algorithms, such as Markov chains and recurrent neural networks (RNNs).

The Solution: A Hybrid Approach to Content Automation

After several weeks of experimentation, I settled on a hybrid approach that combines the strengths of different techniques. The system uses a combination of NLP and machine learning algorithms to analyze my existing content and generate new content. The NLP component is responsible for understanding the structure and syntax of my writing, while the machine learning component is responsible for generating new content based on patterns and trends in my existing content. I've implemented this approach using a combination of Python libraries, including NLTK, spaCy, and scikit-learn. The system is designed to be modular and extensible, allowing me to easily add or remove components as needed.

import nltk
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

def generate_content(topic, length):
    # Tokenize the topic and remove stopwords
    tokens = word_tokenize(topic)
    tokens = [token for token in tokens if token not in stopwords.words('english')]

    # Create a TF-IDF vectorizer
    vectorizer = TfidfVectorizer()

    # Fit the vectorizer to the topic and transform it into a vector
    topic_vector = vectorizer.fit_transform([' '.join(tokens)])

    # Generate a list of potential sentences based on the topic vector
    sentences = []
    for sentence in sentence_database:
        sentence_vector = vectorizer.transform([sentence])
        similarity = cosine_similarity(topic_vector, sentence_vector)
        if similarity > 0.5:
            sentences.append(sentence)

    # Select the top N sentences and concatenate them into a single piece of content
    content = ''
    for sentence in sentences[:length]:
        content += sentence + ' '

    return content

Lessons Learned from My Content Automation Journey

One of the most important lessons I've learned from my content automation journey is the importance of experimentation and iteration. I've tried many different approaches and techniques, and each one has taught me something new and valuable. I've also learned the importance of patience and persistence. Building a content automation system is a complex task that requires a significant amount of time and effort. However, the payoff is well worth it. I've been able to generate high-quality content quickly and efficiently, which has allowed me to focus on other aspects of my business.

What's Next for My Content Automation Project

As I continue to work on my content automation project, I'm excited to explore new technologies and techniques. I'm currently experimenting with generative adversarial networks (GANs) and transformer-based architectures, which have shown promising results in the field of natural language generation. I'm also planning to integrate my content automation system with other tools and services, such as ClickUp and Substack, to create a seamless and automated content creation workflow. My goal is to create a system that can generate high-quality content across multiple platforms and formats, including blog posts, social media updates, and even books and courses. The possibilities are endless, and I'm excited to see where this journey takes me.

Part of my Build in Public series — sharing the real process of building SaaS projects from Playa del Carmen, México.

Repo: zaerohell/content-automation · 2026-06-17

#playadev #buildinpublic

Load the data

Roberto Luna — Thu, 18 Jun 2026 13:46:04 +0000

The Pursuit of Productivity: Automating Content Generation
As I delved into the world of content automation, I found myself entangled in a complex web of code, trying to make sense of the intricacies involved in generating high-quality content. My goal was to create a system that could auto-generate weekly newsletters, reducing the time and effort spent on manual content creation. But, as I soon discovered, this seemingly straightforward task was fraught with challenges. The journey was not just about writing code; it was about understanding the nuances of language, the importance of context, and the need for precision.

The Problem I Faced
I was working on a project called content-automation, and my objective was to automate the generation of weekly newsletters. The problem I faced was not just about creating content, but also about ensuring that the content was relevant, engaging, and accurate. I needed to develop a system that could take into account various factors, such as the topic, tone, and style of the content, and generate high-quality newsletters accordingly. However, as I began to work on the project, I realized that the task was more complex than I had initially anticipated. The system required a deep understanding of natural language processing, machine learning, and data analysis, which made it a daunting challenge.

The Context of My Project
The content-automation project was part of a larger initiative to improve productivity and efficiency in content creation. The project involved developing a system that could auto-generate high-quality content, including weekly newsletters, blog posts, and social media updates. The system was designed to work with various data sources, including news articles, research papers, and social media feeds, to generate content that was relevant, engaging, and accurate. The project was important because it had the potential to revolutionize the way content was created and consumed, making it possible for businesses and individuals to produce high-quality content quickly and efficiently.

My Initial Approach
My initial approach to solving the problem was to use a combination of natural language processing (NLP) and machine learning algorithms to generate content. I used a library called spaCy to perform NLP tasks, such as tokenization, entity recognition, and language modeling. I also used a machine learning library called scikit-learn to develop a model that could predict the relevance and accuracy of the generated content. However, as I began to work on the project, I realized that my approach was flawed. The model was not accurate enough, and the content generated was not engaging or relevant. I had to go back to the drawing board and re-evaluate my approach.

What Went Wrong
One of the main challenges I faced was the lack of high-quality training data. The model required a large dataset of labeled examples to learn from, but I didn't have access to such a dataset. As a result, the model was not able to learn from the data effectively, and the content generated was not accurate or relevant. Another challenge I faced was the complexity of the NLP tasks involved. The system required a deep understanding of language and context, which made it difficult to develop an accurate model. I also struggled with the tone and style of the content, as the model was not able to capture the nuances of language and context.

The Solution I Found
After re-evaluating my approach, I decided to use a different strategy. I used a combination of content templates and data analysis to generate content. The templates provided a structure for the content, while the data analysis provided the necessary information to fill in the templates. I also used a library called pandas to perform data analysis and manipulation tasks. The solution worked well, and I was able to generate high-quality content quickly and efficiently. The code snippet below shows an example of how I used the pandas library to perform data analysis:

import pandas as pd

# Load the data
data = pd.read_csv('data.csv')

# Perform data analysis
data['topic'] = data['text'].apply(lambda x: x.split('.')[0])

# Generate content
content = []
for topic in data['topic'].unique():
    template = 'This week, we discussed {}.'
    content.append(template.format(topic))

# Print the content
print(content)

The code snippet above shows how I used the pandas library to load the data, perform data analysis, and generate content. The apply method was used to apply a lambda function to each row of the data, and the unique method was used to get the unique topics.

Lessons Learned
One of the main lessons I learned from this project was the importance of having high-quality training data. The model was only as good as the data it was trained on, and without high-quality data, the model was not able to learn effectively. I also learned the importance of using the right tools and libraries for the task at hand. The pandas library was instrumental in performing data analysis and manipulation tasks, and the spaCy library was useful for performing NLP tasks. Finally, I learned the importance of being flexible and adaptable when working on a project. The initial approach I used did not work, and I had to be willing to try different approaches until I found one that worked.

What's Next
Now that I have a working solution, I plan to continue improving and refining the system. I want to explore the use of more advanced NLP and machine learning techniques to improve the accuracy and relevance of the generated content. I also want to expand the system to work with other types of content, such as social media updates and blog posts. The potential applications of this technology are vast, and I am excited to see where it can take me. The journey has been challenging, but it has also been rewarding. I have learned a great deal about the importance of productivity, the power of automation, and the potential of technology to transform the way we work and live.

Part of my Build in Public series — sharing the real process of building SaaS projects from Playa del Carmen, México.

Repo: zaerohell/content-automation · 2026-06-14

#playadev #buildinpublic

Building bienestar-integral-kb — 2026-06-14

Roberto Luna — Thu, 18 Jun 2026 13:44:27 +0000

The Never-Ending Quest for Reliable PDF Processing

As a full-stack developer, I've had my fair share of battles with various technologies, but none have tested my patience like PDF processing. It's like trying to tame a wild beast - just when you think you've got it under control, it breaks free and leaves you scratching your head. My latest adventure in this realm began with a seemingly simple task: integrating a PDF upload feature into our application, bienestar-integral-kb, which is a knowledge base for holistic wellness. The goal was to enable users to upload PDF files, extract relevant information, and store it in our database. Sounds straightforward, right? Wrong.

The Problem at Hand

The issue arose when we started testing the upload feature with larger PDF files. Our initial implementation used a popular JavaScript library, pdfjs, to handle the parsing and extraction of data from the uploaded files. However, we soon discovered that this library had some limitations when dealing with big files. It would either take an eternity to process or, worse still, crash altogether. We needed a more robust solution that could handle files of varying sizes without compromising performance. After some research, we decided to explore alternative approaches, including using a different library or even leveraging the power of cloud-based services.

Context: The Bigger Picture

Our application, bienestar-integral-kb, is built using a modern tech stack, with a React-based frontend and a Node.js backend. We're hosted on Vercel, which provides a seamless development experience, but also imposes some limitations when it comes to resource-intensive tasks like PDF processing. Given these constraints, we had to be creative in our approach to handling large PDF files. We couldn't simply throw more resources at the problem; instead, we had to find a way to optimize our implementation and make the most of what we had.

Exploring Alternative Solutions

My first attempt at solving this problem involved using a different library, pdfjs-dist, which promised better performance and support for larger files. I spent several hours integrating this library into our codebase, only to discover that it had its own set of issues. The documentation was sparse, and the community support was lacking. After struggling to get it working, I decided to take a step back and reassess our approach. Maybe we were looking at this problem from the wrong angle. Instead of trying to find a library that could handle large files, perhaps we should focus on optimizing our existing implementation. This led me to explore techniques like chunking, where we break down the PDF file into smaller, more manageable pieces, and process them individually.

The Eureka Moment

The breakthrough came when I stumbled upon an article about using a cloud-based service, Groq, to handle PDF processing. Groq provides a robust API for extracting data from PDF files, and it's designed to handle large files with ease. I was skeptical at first, but after reading through the documentation and testing their API, I was convinced that this was the way forward. We could offload the heavy lifting to Groq, and focus on what we do best - building a great user experience. The integration was relatively straightforward, and we were able to get it up and running in a matter of hours.

The Technical Details

To give you a better idea of how we implemented this solution, let's take a look at some code. We used the pdfjs library to handle the initial upload and parsing of the PDF file, and then we passed the extracted data to Groq for further processing. Here's an example of how we integrated Groq into our codebase:

import { groq } from '@groq/client';

const groqClient = new groq.Client({
  apiKey: 'YOUR_API_KEY',
  apiSecret: 'YOUR_API_SECRET',
});

const uploadPdf = async (file) => {
  const pdf = await pdfjs.getDocument(file);
  const pages = await pdf.getPages();
  const extractedData = [];

  for (const page of pages) {
    const pageData = await page.getTextContent();
    extractedData.push(pageData);
  }

  const groqResponse = await groqClient.extractData({
    data: extractedData,
    options: {
      // Groq options go here
    },
  });

  // Process the extracted data from Groq
  const processedData = await processGroqData(groqResponse);
  return processedData;
};

As you can see, we're using the groq library to interact with the Groq API, and we're passing the extracted data from the PDF file to their extractData method. The rest of the implementation is straightforward - we process the response from Groq and store the extracted data in our database.

Lessons Learned

Looking back on this experience, I've learned a few valuable lessons. Firstly, don't be afraid to explore alternative solutions, even if they seem unconventional. In this case, using a cloud-based service like Groq was the key to unlocking a scalable and reliable PDF processing solution. Secondly, optimize your implementation, don't just throw resources at the problem. By breaking down the PDF file into smaller chunks and processing them individually, we were able to reduce the load on our server and improve performance. Finally, don't underestimate the power of community support. The Groq community was instrumental in helping us get up and running with their API, and their documentation was top-notch.

What's Next?

As we continue to build out our application, we'll be focusing on refining our PDF processing workflow and exploring new features that take advantage of Groq's capabilities. One area we're interested in is using machine learning to extract insights from the uploaded PDF files. By leveraging Groq's API and our own machine learning models, we can unlock new possibilities for our users and provide a more comprehensive knowledge base for holistic wellness. The journey may be long, but with the right tools and a bit of creativity, we're confident that we can overcome any obstacle and build something truly remarkable.

Part of my Build in Public series — sharing the real process of building Building Ismerely KB from Playa del Carmen, México.

Repo: zaerohell/bienestar-integral-kb · 2026-06-14

#playadev #buildinpublic

Building VS — 2026-06-15

Roberto Luna — Thu, 18 Jun 2026 01:37:10 +0000

As I sat in front of my computer, sipping my morning coffee and staring at the lines of code on my screen, I couldn't help but think about how far we've come in terms of automating content. Just a few years ago, the idea of using AI to generate high-quality content would have seemed like science fiction. But now, with the latest updates to our CLAUDE system, we're taking a major leap forward in this direction. The commit I made earlier today, updating the CLAUDE.md file to version 1.5.0, marked a significant milestone in our content automation journey. But what prompted this change, and how did we get here?

The problem we were facing was twofold. On one hand, our content creation process was becoming increasingly manual and time-consuming. With the rise of AI-powered tools, we knew we had to adapt and find ways to automate as much of this process as possible. On the other hand, we were struggling to keep our documentation up-to-date, which was leading to inconsistencies and errors. Our CLAUDE system, which is the backbone of our content management, needed an overhaul to incorporate the latest advancements in AI and automation. The context of this problem was critical, as our system is used by multiple teams across the organization, and any changes we made would have a ripple effect on their workflows.

The context of this update was also closely tied to our DevOps and cybersecurity efforts. As we continue to move more of our infrastructure to the cloud, we need to ensure that our systems are secure, scalable, and efficient. The CLAUDE system is a key part of this effort, as it handles sensitive data and interacts with multiple AI endpoints. Our team had been working on implementing Zod schema validation for these endpoints, which would help prevent input validation errors and ensure the integrity of our data. However, we were still missing a crucial piece of the puzzle - content automation. By updating the CLAUDE system to version 1.5.0, we're taking a significant step towards addressing these challenges and setting ourselves up for success in the long term.

My first approach to solving this problem was to dive headfirst into the code and start making changes. I figured that with my experience and knowledge of the system, I could quickly identify the areas that needed improvement and make the necessary updates. However, as I soon discovered, this approach was flawed. I spent hours poring over lines of code, trying to make sense of the complex interactions between different components, and still, I couldn't seem to crack the code. It wasn't until I took a step back and looked at the bigger picture that I realized what I was missing. I needed to take a more holistic approach, one that took into account the entire system and its various dependencies. This is where our exploration of Docker and containerization came in - by using containers to manage our dependencies and ensure consistency across different environments, we could simplify our development process and reduce the risk of errors.

The solution to our problem came in the form of a comprehensive update to the CLAUDE system. We decided to implement a new content automation feature, which would use AI to generate high-quality content based on predefined templates and guidelines. This feature would not only save us time and effort but also ensure consistency and accuracy across all our content. To make this happen, we had to make significant changes to the underlying code, including updates to the CLAUDE.md file and the introduction of new automation scripts. One of the key changes we made was to the asistente-legal endpoint, which now uses Zod schema validation to prevent input validation errors. For example, we added the following code to validate the input data:

import { z } from 'zod';

const schema = z.object({
  name: z.string(),
  description: z.string(),
});

const inputData = {
  name: 'Example',
  description: 'This is an example',
};

const result = schema.parse(inputData);

if (result.success) {
  console.log('Input data is valid');
} else {
  console.log('Input data is invalid');
}

This code uses the Zod library to define a schema for the input data, and then parses the input data against that schema. If the data is valid, it logs a success message; otherwise, it logs an error message.

As I look back on this experience, I'm reminded of the importance of taking a step back and assessing the situation before diving in. It's easy to get caught up in the details and lose sight of the bigger picture, but by taking a more holistic approach, we can often find solutions that are more effective and sustainable in the long term. One of the key lessons I learned from this experience is the importance of automation and consistency in our development process. By using tools like Docker and containerization, we can simplify our development process and reduce the risk of errors. Additionally, by implementing automation features like content automation, we can save time and effort while ensuring consistency and accuracy across all our content.

As we move forward, there are still several challenges that we need to address. One of the biggest hurdles will be integrating our new content automation feature with the rest of our system, ensuring that it works seamlessly with our existing workflows and tools. We'll also need to continue monitoring and refining our system to ensure that it remains secure, scalable, and efficient. But for now, I'm excited to see the impact that this update will have on our organization, and I'm confident that it will be a major step forward in our journey towards greater automation and efficiency. Our next steps will be to continue testing and refining the CLAUDE system, and to explore new ways to leverage AI and automation to drive innovation and growth. With the latest updates to our system, we're well on our way to achieving our goals and setting ourselves up for success in the long term.

Part of my Build in Public series — sharing the real process of building Building PlayaMXCRM from Playa del Carmen, México.

Repo: zaerohell/VS · 2026-06-15

#playadev #buildinpublic

Building content-automation — 2026-06-15

Roberto Luna — Thu, 18 Jun 2026 01:36:00 +0000

The Quest for Seamless Content Automation

As I reflect on my recent endeavors in content automation, I am reminded of the intricate dance between technology and human intuition. My goal was to streamline the process of generating content for various platforms, including Medium and Substack, using a repository named content-automation. The idea was to leverage automation to save time and increase productivity, allowing me to focus on more creative and high-leverage tasks. However, I soon realized that the journey to achieving this goal was not without its challenges.

The Problem of Manual Content Generation

Manual content generation was a tedious and time-consuming process that involved creating and editing files for each platform, ensuring consistency and accuracy. This process was not only prone to errors but also limited my ability to scale and experiment with different content formats. I needed a solution that would allow me to generate content automatically, while still maintaining the quality and relevance that my audience expected. The question was, where do I start?

The Context of Content Automation

The content-automation repository was designed to serve as a central hub for all my content generation needs. It contained a collection of files and scripts that worked together to generate content for various platforms. The repository was structured in a way that allowed me to easily manage and update content, using a combination of JSON files, Markdown templates, and automated scripts. However, as I delved deeper into the repository, I realized that the existing setup was not optimized for automation, and I needed to make significant changes to achieve my goals.

The Exploration of Automation Options

My first approach was to use a simple script to generate content based on a set of predefined templates. I created a Python script that used the Jinja2 templating engine to render Markdown templates, using data from JSON files. The script worked well for simple use cases, but it quickly became apparent that it was not scalable or flexible enough to handle the complexity of my content generation needs. I needed a more robust solution that could handle multiple platforms, formats, and data sources. After some research and experimentation, I decided to explore the use of more advanced automation tools, such as GitHub Actions and Zapier.

The Solution: Automating Content Generation with GitHub Actions

The breakthrough came when I discovered the power of GitHub Actions, which allowed me to automate the content generation process using a series of workflows and scripts. I created a workflow that used the GitHub Actions API to generate content for each platform, using data from the JSON files and Markdown templates. The workflow was triggered automatically whenever I updated the repository, ensuring that my content was always up-to-date and consistent across all platforms. The result was a seamless and efficient content generation process that saved me hours of manual work each week.

Lessons Learned: The Importance of Automation and Flexibility

The experience taught me the importance of automation and flexibility in content generation. By leveraging the power of GitHub Actions and other automation tools, I was able to streamline my content generation process, reduce errors, and increase productivity. However, I also learned that automation is not a one-time solution, but rather an ongoing process that requires continuous monitoring, testing, and refinement. The key to success lies in finding the right balance between automation and human intuition, allowing me to focus on high-leverage tasks while still maintaining the quality and relevance of my content.

Next Steps: Refining the Automation Process

As I look to the future, my goal is to continue refining the automation process, exploring new tools and technologies that can help me improve efficiency and productivity. I plan to experiment with more advanced automation workflows, using tools like Zapier and IFTTT to integrate my content generation process with other apps and services. I also aim to share my knowledge and experience with others, helping to build a community of content creators who can learn from each other and push the boundaries of what is possible with automation. The journey to seamless content automation is ongoing, but I am excited to see where it takes me.

Part of my Build in Public series — sharing the real process of building SaaS projects from Playa del Carmen, México.

Repo: zaerohell/content-automation · 2026-06-15

#playadev #buildinpublic

Load content data from JSON file

Roberto Luna — Thu, 18 Jun 2026 01:12:47 +0000

The Quest for Seamless Content Automation: Lessons from the Trenches

As I reflect on my journey to automate content processes, I'm reminded of the countless hours spent tweaking scripts, debugging code, and navigating the intricacies of content management systems. It's a quest that has taken me down many rabbit holes, but one that has ultimately led to significant improvements in productivity and efficiency. My latest endeavor, updating the CLAUDE documentation to version 1.5.0, has been a prime example of this journey. With a focus on content automation and audit features, this update has been a crucial step towards streamlining our content workflows.

The Problem of Manual Intervention

One of the primary challenges I faced was the need for manual intervention in our content automation process. Despite having a robust system in place, there were still many tasks that required human oversight, which not only increased the risk of errors but also slowed down the entire process. I knew that I needed to find a way to automate these tasks, but I wasn't sure where to start. I began by analyzing our current workflow, identifying pain points, and researching potential solutions. This led me to explore various automation tools and scripts that could help me achieve my goals.

The Context of Content Automation

Our content automation system, CLAUDE, is a complex beast that involves multiple components, including data ingestion, processing, and output. The system is designed to handle large volumes of content, and as such, it requires a high degree of automation to ensure efficiency and accuracy. However, as the system has evolved, so too have the challenges associated with it. One of the key issues I faced was the need to balance automation with the need for human oversight. While automation is essential for efficiency, it's equally important to ensure that the content being produced is of high quality and meets our standards. This is where the concept of audit features comes into play. By integrating audit features into our automation process, I aimed to create a system that could not only produce content quickly but also ensure that it meets our quality standards.

The Exploration of Automation Tools

My first approach was to explore existing automation tools that could help me streamline our content workflows. I researched various options, including Zapier, IFTTT, and Automator, but none of them seemed to fit our specific needs. I then turned my attention to scripting languages, such as Python and JavaScript, which offered more flexibility and customization options. I spent several days experimenting with different scripts, testing their limitations, and refining my approach. One of the key challenges I faced was integrating these scripts with our existing system, which required significant modifications to our codebase.

The Solution: Custom Automation Script

After several weeks of experimentation, I finally landed on a solution that worked. I developed a custom automation script using Python that could integrate with our existing system and automate many of the tasks that previously required manual intervention. The script used a combination of natural language processing (NLP) and machine learning algorithms to analyze our content and identify areas that required human oversight. This approach not only improved efficiency but also reduced the risk of errors. The script was designed to be modular, allowing me to easily add or remove features as needed. Here's an example of how the script works:

import os
import json
from nltk.tokenize import word_tokenize

# Load content data from JSON file
with open('content.json') as f:
    content_data = json.load(f)

# Tokenize content and analyze using NLP
tokenized_content = word_tokenize(content_data['text'])
nlp_analysis = analyze_nlp(tokenized_content)

# Identify areas that require human oversight
oversight_areas = identify_oversight_areas(nlp_analysis)

# Automate tasks that do not require human oversight
automate_tasks(content_data, oversight_areas)

Lessons Learned from the Journey

One of the key lessons I learned from this experience is the importance of iterative development. Rather than trying to develop a complete solution from the outset, I focused on incrementally building and refining my approach. This allowed me to test and validate my ideas, making adjustments as needed. Another important lesson is the value of modularity. By designing my script to be modular, I was able to easily add or remove features, making it more flexible and adaptable to changing requirements. Finally, I learned the importance of balancing automation with human oversight. While automation is essential for efficiency, it's equally important to ensure that the content being produced is of high quality and meets our standards.

What's Next for Content Automation

As I look to the future, I'm excited to continue exploring new ways to automate and improve our content workflows. One area I'm particularly interested in is the use of artificial intelligence (AI) and machine learning (ML) to enhance our content automation capabilities. By leveraging these technologies, I believe we can create even more efficient and effective content workflows that meet the evolving needs of our organization. Additionally, I'm committed to continuing to share my knowledge and experiences with others, in the hopes of helping them navigate their own content automation journeys. Whether through blog posts, conferences, or online forums, I believe that sharing our collective knowledge and expertise is essential for driving innovation and progress in the field of content automation.

Part of my Build in Public series — sharing the real process of building SaaS projects from Playa del Carmen, México.

Repo: zaerohell/content-automation · 2026-06-16

#playadev #buildinpublic

Building bienestar-integral-kb — 2026-06-16

Roberto Luna — Thu, 18 Jun 2026 01:11:25 +0000

As I sat in front of my computer, sipping my morning coffee and staring at the lines of code on my screen, I couldn't help but think about the complexities of artificial intelligence and its applications in our daily lives. The repository I was working on, bienestar-integral-kb, was a knowledge base for a wellness project that aimed to provide users with a holistic approach to health and wellness. But as I delved deeper into the code, I realized that there was a problem that needed to be addressed - the context of our AI-powered tool, CLAUDE, was not accurately represented in our documentation.

The problem was that our documentation for CLAUDE was outdated and did not reflect the current capabilities and limitations of the tool. This was causing confusion among our users, who were expecting CLAUDE to perform tasks that it was not designed to do. For example, some users were trying to use CLAUDE as a diagnostic tool, which was not its intended purpose. This mismatch between user expectations and the actual capabilities of CLAUDE was leading to frustration and disappointment. As a developer, it was my responsibility to ensure that our documentation was accurate and up-to-date, so that users could get the most out of our tool.

The context of this problem was critical, as it involved not only the technical aspects of CLAUDE but also the overall user experience. Our project, bienestar-integral-kb, was designed to provide a comprehensive approach to wellness, and CLAUDE was a key component of that approach. If our documentation was not accurate, it could undermine the entire project and lead to a loss of trust among our users. Furthermore, as we were using Docker to containerize our application and deploy it to the cloud, any inconsistencies in our documentation could have significant implications for our cybersecurity and productivity.

As I began to explore the issue, I realized that I needed to update our documentation to reflect the current state of CLAUDE. I started by reviewing our existing documentation and identifying the areas that needed to be updated. I then began to rewrite the documentation, using language that was clear and concise, and avoiding any terms that could be misleading or confusing. For example, I made sure to use phrases such as "can support" and "guides towards" instead of "cures" or "treats", to ensure that users understood the limitations of CLAUDE. I also made sure to include information about the microsite, which was a public-facing component of our project, and how it should be used.

The solution to this problem involved a series of technical updates to our documentation. Specifically, I updated the CLAUDE.md file to reflect the current context and capabilities of the tool. The commit history for this update shows the changes I made:

commit a6898af9
Author: Roberto Luna Osorio <roberto.luna.osorio@example.com>
Date:   Thu Jun 16 10:45:23 2023 -0500

    docs: update CLAUDE.md context

diff --git a/CLAUDE.md b/CLAUDE.md
index 34a4567..1234567 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -199,3 +199,53 @@ Admin crea cotización en tab "Cotizador"
- Usar: "puede apoyar", "orienta hacia", "favorece"
- Evitar: "cura", "trata", "diagnostica", "prescribe"
- Micrositio público: sin pre

As I worked on the solution, I realized that the key to success was to be clear and concise in our documentation, and to avoid using language that could be misleading or confusing. I also learned the importance of keeping our documentation up-to-date, as this could have significant implications for our users and our overall project.

One of the key lessons I learned from this experience was the importance of accuracy and clarity in documentation. As developers, we often focus on the technical aspects of our projects, but we must not forget the importance of communicating effectively with our users. This experience taught me to be more mindful of the language we use in our documentation, and to ensure that it is clear, concise, and accurate. I also learned the value of using version control systems, such as Git, to track changes to our documentation and to collaborate with other developers.

As I look to the future, I know that there is still much work to be done to ensure that our documentation is accurate and up-to-date. I plan to continue reviewing and updating our documentation on a regular basis, to ensure that it reflects the current state of our project and tools. I also plan to work with other developers to establish clear guidelines for documentation, to ensure that we are all using consistent language and formatting. By doing so, I hope to create a more user-friendly and intuitive experience for our users, and to ensure that our project is successful in its mission to provide a holistic approach to wellness.

Part of my Build in Public series — sharing the real process of building Building Ismerely KB from Playa del Carmen, México.

Repo: zaerohell/bienestar-integral-kb · 2026-06-16

#playadev #buildinpublic