DEV Community: Jawuil Pineda

The Harness Is Not Intelligence: What Is Actually Improving in AI Agents?

Jawuil Pineda — Sun, 06 Sep 2026 17:04:23 +0000

A few months ago, I wrote about a feeling I still have today: AI models, and especially coding agents, no longer give me the same sense of huge leaps that they used to.

I am not saying they are not improving. Newer models usually make fewer mistakes, follow instructions better, and sometimes solve problems that older versions could not. But it is becoming harder for me to feel those improvements as a real jump in capability.

Recently, I saw a post arguing, more or less, that at this point models are no longer better or worse than each other, but simply have different behaviors, and that what is actually good or bad is the harness controlling them. It even suggested that if someone is still complaining about current models, they probably do not know how to use or control them properly.

I agree with part of that idea.

But I think taking it that far is a mistake.

The harness matters a lot

First, we need to separate things that are often thrown into the same bucket.

A model is not an agent.

GPT, Claude, Gemini, GLM, or any other LLM is only one part of the system. Around the model there is an entire infrastructure: tools, context management, system prompts, planning, retries, and many other things.

That is, simplifying a lot, the harness.

And after spending time building my own coding agent, I am even more convinced that this layer matters enormously.

You can put the exact same model inside two different products and get completely different experiences.

One agent may manage context better than another. It may have better tools, recover from errors more effectively, or provide the model with more relevant information for completing a task.

All of that changes the result.

So yes: simply saying “this model is bad because it performed badly inside X agent” can be unfair.

But there is a huge distance between that and saying that models are no longer better or worse.

The result does not depend only on the harness

To me, the result of an agent looks more like this:

Result = model + harness + context + tools + instructions + task

Obviously, this is not a real mathematical formula, but it is useful for understanding the problem.

Change the harness, and the result changes.

Change the model, and the result changes too.

I have seen this many times while using different models in similar environments.

I have tried models that, on paper, were supposedly comparable to frontier models, but in the same kinds of projects they simply performed worse. They needed more corrections, forgot instructions more often, or made worse decisions.

The harness was still practically the same.

What changed was the model.

That is why I do not think we can reduce every current difference between models to simple “behavior.”

If a certain behavior causes one model to complete a task correctly much more often than another, that difference eventually becomes practical capability.

The question is no longer whether they can do it

I think this is the most interesting part of the whole discussion.

A few years ago, the question was:

Can an AI do this?

Can it build an application? Can it modify multiple files? Can it understand an error and fix it?

Today, for many of those questions, the answer is simply yes.

The problem is now different:

Can it do it correctly and consistently?

Because the fact that a model can do something does not mean you can trust it to do it correctly every time.

And that is where I still see major problems.

A very simple example: do not use `alert()`

Recently, I was working with Claude Code on an existing project.

I explicitly told it that I did not want to use alert() for confirmations. The application was supposed to use a modal.

Claude Code understood the instruction.

In the section we were working on, it correctly replaced the alert() with a modal.

But later, in another related part of the system, it left another alert() in place.

And I think this is a pretty good representation of the current state of many agents.

The system knew how to do the job.

It had understood my instruction and had even demonstrated that it knew how to implement the correct alternative.

And yet it failed to maintain that decision consistently across the project.

What makes this example interesting is that I was not using some experimental harness I had just built. I was working with Claude Code, a tool specifically designed to work agentically on codebases.

So an important question appears:

Whose fault was it?

It could have been my fault if I had never given the instruction.

It could have been the harness if that instruction had disappeared from the context.

It could have been an agent problem if it never inspected the other relevant parts of the project.

But if the model has the instruction, has access to the necessary code, and still ignores an explicit constraint, there is a point where we have to accept something pretty simple:

the model made a mistake.

Not every failure can automatically become a harness failure.

A good harness can hide a model's limitations

I think there is an important source of confusion here.

If we know that our models often forget certain constraints, we can build systems that review their work, run tests, retry failed attempts, or repeatedly reinsert important project rules into the context.

All of that can improve the final result dramatically.

But there is something we should not confuse:

we did not necessarily make the model smarter.

We built mechanisms to detect, prevent, or correct its mistakes.

And that is progress too. In fact, it is an extremely important part of building agents.

But a good harness often does not remove the model's limitations.

It compensates for them.

And if it works well enough, it can even make those limitations almost invisible to the user.

This also makes measuring progress more complicated.

If a new version of an agent feels much better, did the model itself really improve? Did context management improve? Did they add a review phase? Does it now retry more often before giving up?

From the outside, all of that often gets summarized as “the AI got better,” even though technically those are very different things.

From capability improvements to reliability improvements

I think this is one of the reasons why I feel that models are advancing more slowly.

During some stages of LLM development, the jumps were very easy to notice.

Before, a model simply could not do a certain task.

Then it could.

That is a qualitative jump.

The current feeling, at least for me, is different.

A lot of the progress now looks more like the model making slightly fewer mistakes, needing fewer attempts, or staying on track for longer tasks.

That is still progress.

And in production, it can be extremely valuable.

But it does not feel like having a model that is ten times more intelligent.

It feels like having one that is less fragile.

Maybe we are entering a stage where many of the visible improvements are improvements in reliability rather than entirely new capabilities.

That also explains why trying a new model sometimes leaves me relatively unimpressed.

It may be better.

It may make fewer mistakes.

But I still have to review its work, correct strange decisions, and verify that it actually did everything I asked.

The jump is still not large enough to completely change the way I work.

Building software from scratch is still easier than maintaining it

There is another limitation I keep seeing: models are much better at creating software from scratch than working on existing systems.

When a model starts a new project, it gets a huge advantage.

It can choose the architecture, establish its own conventions, and create the abstractions it needs.

In a sense, it is solving a problem inside a world that it just created itself.

Working on an existing project is completely different.

Now it has to understand decisions that were already made, find dependencies, respect conventions, and avoid breaking existing behavior.

It has to reconstruct something close to the mental model of a developer who already knows the system.

That is where I still see a lot of problems.

Sometimes the generated code is individually correct, but the complete change is still wrong.

One part uses the new implementation while another continues using the old one. A component gets changed but not every place that depends on it. Or an existing design decision gets broken somewhere else in the project.

The AI may understand every individual piece and still lose global coherence.

That is why I think one way of describing the current problem is:

LLMs are much better at generating code than maintaining invariants across complex systems.

And that matters a lot in real software engineering.

A new landing page can come out reasonably well from a single prompt.

Modifying an application that has spent months or years accumulating decisions, dependencies, and conventions is a different story.

And that is where I still do not feel we have seen the huge jump that is often advertised.

The problem with saying it is always the harness's fault

This is the part that bothers me most about the idea that if someone complains about current models, they simply “do not know how to control them.”

Because that can easily become an unfalsifiable position.

If the model works well, that proves the model is good.

If it performs badly, the harness was bad.

If someone gets worse results, they do not know how to use it properly.

At what point are we allowed to accept that the model itself simply has a limitation?

If every failure can be explained after the fact as a problem external to the model, then we have created a hypothesis that can never lose.

And that is not a particularly useful way to evaluate technology.

Of course we should improve our agents and learn to use models better.

But we should also be able to say:

The model failed here.

Without automatically turning the error into the user's fault.

And there is another point: when we need to build more and more layers around a model to make sure it completes a task correctly, those layers are also telling us something about the model's limitations.

The harness exists precisely because the model by itself is not enough.

That is not a criticism of the harness.

It is its reason for existing.

Prompt engineering did not disappear either

Something similar happened with the idea that models would become so intelligent that prompt engineering would no longer matter.

I do think it has changed.

I no longer think it is very useful to fill prompts with strange phrases or search for magical word combinations. Current models understand normal instructions much better.

But that does not mean structuring instructions stopped mattering.

If I want an agent to inspect an existing implementation first, respect certain constraints, and avoid modifying specific parts of the project, telling it that is still useful.

Providing relevant context and clearly defining the expected result still matters.

Maybe prompt engineering simply evolved into something larger: context engineering.

We are no longer thinking only about the sentence we type.

We are thinking about what information the model needs to know when it makes each decision.

And that is directly related to harness design.

Models do not need to feel radically different anymore

I also think there is another phenomenon at play.

Current models have already crossed a fairly high capability threshold.

Good models can code, understand existing code, use tools, and work through multi-step tasks.

Once all of them pass that minimum level, the differences stop feeling as dramatic.

A model that successfully completes 85% of my tasks and another that completes 90% can feel relatively similar during a conversation.

And both of them are still capable of doing something incredibly stupid five minutes later.

That remaining percentage of errors may also appear precisely in the hardest parts of the work.

So two statements that seem contradictory can both be true:

Current models are extraordinarily capable.

And:

Current models are still frustratingly unreliable.

I think both are true.

And maybe that is why many comparisons today focus more on small percentage improvements than on completely new capabilities.

That does not mean those improvements are irrelevant.

It simply means they do not all represent a major leap in intelligence.

So, are agents actually improving?

Yes.

But I think we should be more precise when we talk about those improvements.

Sometimes the model improves. Other times the harness improves, the tools improve, or simply our way of using them improves.

And usually, all of those things evolve at the same time.

Putting everything under a sentence like “AI is much smarter now” makes it difficult to understand what kind of progress we are actually seeing.

My current impression is that a significant part of the recent improvement in coding agents comes from building better systems around models that were already extremely capable.

That does not mean models stopped improving.

And it definitely does not mean that all models are equivalent.

It means that maybe the frontier we are trying to push has changed.

For years, we were trying to make models capable of doing new things.

Now the challenge may be getting them to reliably do the things we already know they can do.

Because an AI being able to write an application does not surprise me that much anymore.

What would surprise me is being able to leave it working for hours on a real codebase, come back, and find that it understood the existing decisions, preserved the important constraints, and did not leave behind a collection of small mistakes that I now have to chase down.

That, to me, would feel like another real leap.

Maybe the next major breakthrough in agents will not be getting them to do new things.

Maybe it will be getting them to do the things they already know how to do well, consistently, and without constant supervision.

Best AI Coding Assistants for Sublime Text in 2026

Jawuil Pineda — Fri, 21 Aug 2026 19:15:38 +0000

Sublime Text remains one of the fastest and most lightweight code editors available, but for years AI tooling has been much stronger in editors such as VS Code, Cursor, and JetBrains IDEs.

That is starting to change.

Sublime Text's AI ecosystem is still relatively small, but in 2026 there are several interesting options representing very different ways of coding with AI: autocomplete, LLM chat, pair programming, and external coding agents.

In this article, I compare four of the most relevant approaches currently available for Sublime Text.

Disclosure: I am the developer of Limitcode, one of the tools included in this comparison. I have tried to keep the article focused on each tool's capabilities and the workflow it is designed for.

Quick comparison

AI assistant	Best for	Chat	File editing	Project-wide access	External agent/CLI
Limitcode OSS	Native controlled pair programming	Yes	Yes, open files	No	No
TermMate	External coding agents	Yes	Through the agent	Yes	Yes
OpenAI Completion	General LLM chat and assistance	Yes	Not its primary focus	No	No
LSP-copilot	GitHub Copilot autocomplete	Yes	Suggestions	No	No

The important distinction is that these tools are not trying to solve exactly the same problem.

1. Limitcode OSS — Best for native controlled AI pair programming

Best for: Developers who want AI to read and modify code directly inside Sublime Text without automatically giving it access to the entire project.

Limitcode is an open-source AI pair programming agent built specifically for Sublime Text.

Its approach is deliberately different from fully autonomous coding agents.

Limitcode OSS can only work with files that are already open in the active Sublime Text window. It can read them, modify their contents, and write changes directly back into those files.

It does not silently scan your repository and it cannot execute commands on your machine.

The idea is for the AI to work with you on the code you explicitly choose to expose.

Main features

Native Sublime Text interface
Streaming chat
Persistent conversation history
Read access to open files
Direct editing of open files
@file references
Per-session model and provider switching
Configurable reasoning effort
OpenAI
Anthropic
Gemini
DeepSeek
Ollama
LM Studio

Ollama and LM Studio also make it possible to use local models without configuring a cloud provider API key.

Limitcode OSS deliberately exposes a small tool surface to the agent.

It can read and edit the code you have opened, but it cannot automatically explore closed files, create arbitrary new files, execute shell commands, or take control of the entire project.

That makes the workflow closer to pair programming than autopilot.

Pros

Built specifically for Sublime Text
Native editor experience
Can read and modify code
Multiple AI providers
Local model support
No external coding-agent CLI required
Explicit and controlled access to code
Open source

Cons

Cannot automatically explore the entire project
Cannot work with closed files
Cannot create new files in the OSS edition
No shell execution
Relatively new project Choose Limitcode OSS if: you want something closer to an AI pair programmer than a chatbot, but do not want to give an autonomous agent automatic access to your entire development environment.

What about Limitcode Pro?

Limitcode OSS is designed around controlled pair programming.

Limitcode Pro takes the same native Sublime Text experience toward a much more agentic workflow with capabilities including:

Project-wide file exploration and search
File creation and editing
Permission-controlled shell execution
Web search and page fetching
MCP
Skills
Subagents
Snapshots for restoring changes
Automatic management of larger contexts

Everything still runs inside Sublime Text, but the agent can take responsibility for much larger development tasks.

Explore Limitcode Pro →

2. TermMate — Best for Claude Code, Codex and external agents

Best for: Developers who want to use powerful external coding agents while keeping Sublime Text as their primary editor.

TermMate takes a very different approach.

Instead of implementing its own agent inside the Sublime Text plugin, it acts as an interface between Sublime Text and external coding agents such as Claude Code, Codex, and Pi Agent.

This gives developers access to much more autonomous workflows while keeping interaction with the agent close to the editor.

Depending on the underlying agent, it can explore a project, modify files, use tools, and handle multi-step development tasks.

TermMate also aims to preserve the Sublime Text experience by using a native interface rather than relying on a heavy webview.

Pros

Works with powerful external coding agents
Claude Code and Codex integration
Suitable for multi-step development tasks
Keeps Sublime Text as the primary editor
Interface designed around Sublime Text

Cons

Depends on external tools
May require additional installations and authentication
Behavior depends on the underlying agent
More moving parts than a self-contained solution

The architectural difference with Limitcode is straightforward:

TermMate connects Sublime Text to existing external agents.
Limitcode implements its agent workflow directly inside Sublime Text.

Neither approach is inherently better. They solve different problems.

Choose TermMate if: you already use Claude Code, Codex, or similar external agents and want to integrate them more closely with Sublime Text.

3. OpenAI Completion — Best for general LLM chat and assistance

Best for: Developers who want a flexible LLM assistant directly inside Sublime Text.

Despite its name, OpenAI Completion is no longer limited exclusively to OpenAI.

The plugin can work with different providers and compatible APIs, including configurations using local models.

Its experience is primarily centered around chat: you can talk to a model, send entire files or parts of them as context, receive streaming responses, and display results directly in the editor using Sublime Text phantoms.

That puts it in a different category from tools such as Limitcode or TermMate.

OpenAI Completion is primarily an LLM assistant integrated into Sublime Text, rather than a coding agent whose main purpose is to autonomously operate across a project.

The project also remains actively maintained in 2026, so it should not be confused with the many early ChatGPT plugins that appeared and were later abandoned.

Pros

Established Sublime Text project
Chat directly inside the editor
Streaming
Files and code snippets as context
Multiple providers
OpenAI-compatible APIs
Can work with Ollama and other local backends
Native Sublime Text phantoms

Cons

Primarily chat-oriented
Not focused on agentic file editing
Not designed as an autonomous project-wide coding agent
Can require more configuration than simpler assistants Choose OpenAI Completion if: you mainly want to talk to different LLMs and use your code as context directly from Sublime Text.

4. LSP-copilot — Best for GitHub Copilot in Sublime Text

Best for: Developers who already use GitHub Copilot and primarily want AI-powered code completion inside Sublime Text.

LSP-copilot solves a much more focused problem.

It integrates GitHub Copilot with Sublime Text through the editor's LSP ecosystem and provides AI-generated suggestions while you type.

Its current feature set includes inline completions, phantom completions, panel completions, and chat.

Instead of asking an agent to modify an entire project, Copilot works alongside your normal coding workflow by trying to predict the code you want to write next.

Pros

GitHub Copilot inside Sublime Text
Inline AI completions
Phantom completions
Panel completions
Chat
Integration with Sublime Text's LSP ecosystem
Less intrusive than a full coding agent

Cons

Requires access to GitHub Copilot
Tied primarily to the Copilot ecosystem
Mainly focused on completions
Not designed as an autonomous project-wide agent Choose LSP-copilot if: what you primarily want is the GitHub Copilot autocomplete experience inside Sublime Text.

Which AI assistant should you use with Sublime Text?

It mainly depends on how much control you want to give the AI and what you expect it to do.

If you want AI autocomplete while you type, LSP-copilot is probably the most natural choice.

If you want LLM chat with code context and multiple providers, OpenAI Completion offers a more traditional assistant experience.

If you want to use powerful external agents such as Claude Code or Codex from Sublime Text, TermMate provides an interesting bridge between both worlds.

If you want a native agent that can read and modify the code you have explicitly opened without depending on an external coding-agent CLI or automatically accessing your entire project, Limitcode OSS is designed specifically around that workflow.

And if you want to keep Limitcode's native experience while giving the AI significantly more autonomy across complete projects, that is where Limitcode Pro comes in.

See Limitcode Pro →

Sublime Text's AI ecosystem is finally getting interesting

Sublime Text still has a considerably smaller AI ecosystem than VS Code.

But there is no longer only one way to use AI with the editor.

You can now choose between:

GitHub Copilot autocomplete
Chat with different LLMs
Fully autonomous external agents
Native controlled pair programming

Sublime Text's plugin API, native views, phantoms, commands, and LSP ecosystem provide enough building blocks for surprisingly capable AI tools without turning the editor into a Chromium-based IDE.

For developers who continue to use Sublime Text because of its speed, simplicity, and lightweight experience, switching editors solely to get modern AI tooling is becoming increasingly unnecessary.

AstroKit: Astro's Boilerplate for Launching Your Next Project in Record Time 🚀

Jawuil Pineda — Mon, 23 Feb 2026 16:00:47 +0000

If you're a web developer or an indie hacker, you probably know the thrill of having a new idea for a micro-SaaS or a side project. But you also know the most tedious part: the first 3 or 4 hours (sometimes days) configuring the environment, the framework, basic integrations, and folder structure.

As developers, we want to write our product logic and ship quickly, not reinvent the wheel by configuring the same thing over and over again.

To solve this problem, today I present AstroKit.

🛑 The Problem: Initial Friction
Every time I started a new project, I found myself repeating the same process:

Install the framework.

Configure the linter and code formatter.

Integrate Tailwind CSS (or your favorite styling tool).

Prepare the basic component structure and SEO.

That initial friction is the number one enemy of productivity and creative drive. In the minimalist entrepreneurship philosophy, speed to launch is everything for validating an idea.

⚡️ The Solution: What is AstroKit?
AstroKit is an Astro boilerplate designed specifically for builders and creators who value their time. It packages best practices and modern tools into a single, ready-to-use template.

The goal is simple: to go from idea to code in minutes.

Why choose Astro?
Astro has become one of the best options for building fast websites, blogs, portfolios, and SaaS landing pages thanks to its Island architecture and zero-JavaScript by default. By combining Astro with a robust boilerplate, you get:

Extreme performance (Perfect scores in Lighthouse).

Flawless development experience (DX).

Flexibility to use your favorite React, Vue, or Svelte components if needed.

🚀 We're live on Product Hunt!

Launching a product is always a huge milestone, and today AstroKit is officially on Product Hunt.

If you're a maker, enjoy building in public, or are simply looking to optimize your workflow for your next project, I'd love for you to check it out. Your technical feedback and support mean a lot to me in continuing to improve this tool.

👉 Support AstroKit on Product Hunt here : https://www.producthunt.com/products/astrokit

💬 Let's talk! I want to know what other developers on Dev.to think: What's the one tool or configuration that should always be in your initial stack when starting a project from scratch?

Leave it in the comments, and I'll see you on Product Hunt! 🚢

markdown-for-agents-why-html-is-dying-for-ais

Jawuil Pineda — Sun, 15 Feb 2026 20:24:43 +0000

We're still obsessed with Core Web Vitals and traditional human SEO. But there's an uncomfortable reality growing in web traffic: AI Agents.

Unlike users, AI agents (like those from OpenAI, Anthropic, or Perplexity) don't care about your CSS or animations. They care about structured data. And unfortunately, we're feeding them that data in the worst possible format: heavy, messy HTML.

Cloudflare just launched Markdown for Agents, a solution that promises to be a game-changer for "AI SEO." Here's what it is, why you should enable it, and how it impacts your LLM costs.

The Problem: Your HTML Is "Garbage" for an LLM

Feeding a language model with raw HTML is inefficient. A <nav> tag, dozens of nested divs, and tracking scripts have no semantic value for a bot. It's noise.

According to data published by Cloudflare, an average blog post weighs 16,180 tokens in HTML. That same content, converted to Markdown, weighs only 3,150 tokens.

We're talking about an 80% reduction in token usage.

If you're building AI applications or want your content to be cited by them, this metric is worth its weight in gold. Fewer tokens mean faster responses and less computational cost.

What is Cloudflare Markdown for Agents?

It's a new feature that enables real-time content conversion at the edge.

Instead of forcing the agent developer to scrape and clean your HTML (using their own resources), the Cloudflare network detects the request and transforms your HTML into clean Markdown before sending it.

The result is an optimized document, free of the "dead weight" of web design, ready to be consumed by an LLM.

How to Implement Markdown for Agents (Tutorial)

The implementation is based on standard content negotiation. You don't have to install anything on your server; everything happens in the Cloudflare layer.

Step 1: The Request

The AI agent (or you, if you're testing) must include a specific header in the HTTP request:

Accept: text/markdown

Step 2: The Response

Cloudflare intercepts this header. If the functionality is enabled in your region, it will retrieve the HTML from your source, convert it, and return Markdown.

You can try it right now with this command in your terminal against the Cloudflare documentation:

curl [https://developers.cloudflare.com/fundamentals/reference/markdown-for-agents/](https://developers.cloudflare.com/fundamentals/reference/markdown-for-agents/) \
-H "Accept: text/markdown"

The response also includes an x-markdown-tokens header that tells you the estimated number of tokens in the document, ideal for managing context windows in your applications.

Requirements and Availability: Is it free?

Here's the important detail for indie hackers and developers. Although the tool is powerful, it's not available for all plans at the moment.

Status: Open Beta.
Supported Plans: Pro, Business, and Enterprise.
SaaS: Also included if you're an SSL for SaaS customer.
Free Plan: Currently not included in the free plan.

To activate it, go to your Cloudflare dashboard, select your zone, and find the toggle under "Quick Actions."

Conclusion: The SEO of the Future is Semantic

If you have a SaaS project, technical documentation, or a blog and already pay for a Cloudflare plan, activate it today.

Markdown for AI tools (LLM Optimization) is the next big battle for traffic. If your content is easier for an agent to read than your competitors', you have a huge competitive advantage.

It's not just about code; it's about distribution. In 2026, making life easier for bots is a smart business strategy.

Source: https://blog.cloudflare.com/markdown-for-agents/

I work in agriculture by day and code AI by night. Roast my first SaaS MVP!

Jawuil Pineda — Sun, 07 Dec 2025 01:23:15 +0000

Hi Indie Hackers! 👋

My name is Jawuil, I'm a 21-year-old developer from Venezuela.

The Context: My daily life is quite different from the typical Silicon Valley dev. I live in a rural area and work in agriculture on my family's farm during the day. But every night (and whenever I have a break), I'm glued to my laptop learning to code and building products. I started my coding journey seriously around mid-2024.

The Problem: I noticed that generic prompts don't work everywhere. Trying to use a simple ChatGPT prompt inside complex tools like Cursor (for code), v0.dev, or Jasper usually gives average results. Each AI needs a specific format or structure to work correctly.

The Solution: I built https://accelprompt.xyz/

It is a specialized prompt generator designed to create optimized instructions for specific AI tools. It supports:

Coding: Cursor, v0.dev, Lovable.

Writing: Jasper, Copy.ai.

Visuals: DALL-E, Sora (Video).

It handles the formatting so you just focus on the idea, and it generates the precise instruction the AI needs.

The "Boring" Stack: I believe in shipping fast, so I kept it simple:

Backend: Vanilla PHP (Yes, really!) & Supabase for Auth.

Frontend: Tailwind CSS & Vanilla JS.

Payments: I'm using Ko-fi right now to keep fees low while I validate the idea. It's not fancy, but it works.

Where I need your help: To be honest, I haven't done any real marketing yet. This post is my first time sharing it publicly. Marketing is my biggest weakness right now, and I often feel scattered trying to promote my work while balancing my day job.

Roast my landing page: I just updated the H1 to be more specific. Is the value proposition clear now?

Pricing/Stack: Do you think using Ko-fi for a SaaS is a dealbreaker for users, or is it fine for an MVP?

Thank you so much for reading. The Indie Hackers community has been a huge inspiration for me to keep pushing despite the challenges here.

Cheers! Jawuil

I work in agriculture by day and code AI by night. Roast my first SaaS MVP!

Jawuil Pineda — Sun, 07 Dec 2025 01:15:23 +0000

Hi Indie Hackers! 👋

My name is Jawuil, I'm a 21-year-old developer from Venezuela.

The Solution: I built https://accelprompt.xyz

It is a specialized prompt generator designed to create optimized instructions for specific AI tools. It supports:

Coding: Cursor, v0.dev, Lovable.

Writing: Jasper, Copy.ai.

Visuals: DALL-E, Sora (Video).

It handles the formatting so you just focus on the idea, and it generates the precise instruction the AI needs.

The "Boring" Stack: I believe in shipping fast, so I kept it simple:

Backend: Vanilla PHP (Yes, really!) & Supabase for Auth.

Frontend: Tailwind CSS & Vanilla JS.

Payments: I'm using Ko-fi right now to keep fees low while I validate the idea. It's not fancy, but it works.

Roast my landing page: I just updated the H1 to be more specific. Is the value proposition clear now?

Pricing/Stack: Do you think using Ko-fi for a SaaS is a dealbreaker for users, or is it fine for an MVP?

Thank you so much for reading. The Indie Hackers community has been a huge inspiration for me to keep pushing despite the challenges here.

Cheers! Jawuil

Free tool to remove watermarks from AI images, 100% private

Jawuil Pineda — Sat, 29 Nov 2025 21:00:07 +0000

I've created a tool to remove watermarks from images.
Perfect for those who experiment with AI and create many images with it.
It's FREE and 100% private; your images are not sent to any server. Everything is processed in your browser thanks to OpenCV technology.

https://jawuil.dev/remove-watermark

Tool to create free n8n flows without login (in beta)

Jawuil Pineda — Tue, 04 Nov 2025 18:28:13 +0000

Hello everyone!

I'm creating a tool to help you build n8n flows using AI, and I'd appreciate any feedback or suggestions.

Here's the link; it's free to use, no registration required.

https://jawuil.dev/n8n-flow

DEV Community: Jawuil Pineda

The Harness Is Not Intelligence: What Is Actually Improving in AI Agents?

The harness matters a lot

The result does not depend only on the harness

The question is no longer whether they can do it

A very simple example: do not use alert()

A good harness can hide a model's limitations

From capability improvements to reliability improvements

Building software from scratch is still easier than maintaining it

The problem with saying it is always the harness's fault

Prompt engineering did not disappear either

Models do not need to feel radically different anymore

So, are agents actually improving?

Best AI Coding Assistants for Sublime Text in 2026

Quick comparison

1. Limitcode OSS — Best for native controlled AI pair programming

Main features

Pros

Cons

What about Limitcode Pro?

2. TermMate — Best for Claude Code, Codex and external agents

Pros

Cons

3. OpenAI Completion — Best for general LLM chat and assistance

Pros

Cons

4. LSP-copilot — Best for GitHub Copilot in Sublime Text

Pros

Cons

Which AI assistant should you use with Sublime Text?

Sublime Text's AI ecosystem is finally getting interesting

AstroKit: Astro's Boilerplate for Launching Your Next Project in Record Time 🚀

markdown-for-agents-why-html-is-dying-for-ais

The Problem: Your HTML Is "Garbage" for an LLM

What is Cloudflare Markdown for Agents?

How to Implement Markdown for Agents (Tutorial)

Step 1: The Request

Step 2: The Response

Requirements and Availability: Is it free?

Conclusion: The SEO of the Future is Semantic

I work in agriculture by day and code AI by night. Roast my first SaaS MVP!

I work in agriculture by day and code AI by night. Roast my first SaaS MVP!

Free tool to remove watermarks from AI images, 100% private

Tool to create free n8n flows without login (in beta)

A very simple example: do not use `alert()`