DEV Community: Manuel Bruña

Weekend experiment: controlling the cursor with hand gestures

Manuel Bruña — Fri, 05 Jun 2026 21:10:31 +0000

Some projects are useful immediately.

Some are useful because they make you learn by playing.

Control Cursor With Hand is one of those experiments.

Repo:
https://github.com/tecnomanu/control-cursor-with-hand

The idea is simple: use computer vision to track hand gestures and control the cursor.

It is a hobby project, but it connects with topics I care about:

human-computer interaction
accessibility
gesture interfaces
OpenCV experiments
natural controls for desktop workflows

Not every open-source repo needs to be a product.

Some repos are a place to test an idea, learn a library and see what feels possible.

For me, these small experiments often feed back into bigger AI tooling work.

Agents, browser automation, computer vision and local tools all share one thing: they expand what software can do on your machine.

This one is just a fun step in that direction.

If you have built gesture-based controls or accessibility experiments, I would like to see what worked and what failed.

Bootstrapping projects from guided prompts with MCP

Manuel Bruña — Fri, 05 Jun 2026 21:09:44 +0000

Prompting an agent to create a project is easy.

Getting repeatable project structure is harder.

That is why I built Bootstrap Project MCP.

Repo:
https://github.com/tecnomanu/bootstrap-project-mcp

The idea: use MCP to create complete projects from templates and guided prompts.

Instead of starting every new project from a vague prompt, the agent can call a tool, ask for the right inputs and generate a working base.

The first version focused on MCP templates:

basic
api integration
http

It also supports different creation modes:

assistant
interactive
quick

The project came from a technical demo, but the bigger idea is still useful: agents need repeatable workflows, not only free-form text generation.

A good template gives the agent a solid starting point.

APC can then help keep long-term project context clean after the project exists.

So I see these as connected layers:

Bootstrap Project MCP creates the starting structure
APC stores durable project context
MCP tools connect the agent to useful capabilities

If you build with agents, I think project bootstrapping should become more explicit and less magical.

A tiny MCP server for Telegram notifications from AI agents

Manuel Bruña — Fri, 05 Jun 2026 21:08:57 +0000

Agents need a way to notify humans.

Not every task should stay hidden inside an IDE or terminal.

Sometimes an agent finishes a job, needs approval, hits a blocker or wants to send a generated artifact.

For that, I built MCP Telegram Agent.

Repo:
https://github.com/tecnomanu/mcp-telegram-agent

It is a small TypeScript MCP server over stdio.

The goal is simple: let any MCP-compatible AI agent send a Telegram message with one tool call.

What it includes:

send Telegram notifications
validate config before sending
token-first setup
guided onboarding flow
setup code verification
auto-generated MCP config snippet
support for npx usage

The part I care about most is onboarding.

MCP tools often fail not because the tool logic is hard, but because setup is confusing.

A user should not have to guess the chat id, paste unsafe full API URLs or debug config by trial and error.

This project tries to make that path smaller.

Run with:

npx -y mcp-telegram-agent

If you build MCP servers, I think onboarding deserves as much design as the tool itself.

What if your agent could record product docs as narrated videos?

Manuel Bruña — Fri, 05 Jun 2026 21:08:10 +0000

Documentation gets old fast.

Product videos get old even faster.

I wanted to explore a workflow where an agent can inspect an app, record browser flows, generate narration and assemble videos automatically.

That became Video Docs Builder.

Repo:
https://github.com/tecnomanu/video-docs-builder

The idea is simple:

Playwright records the browser.

TTS generates narration.

FFmpeg assembles the final video.

The output is an mp4 with narration synced to browser interactions.

The project can also generate a small React docs site with the videos embedded.

Why this matters:

onboarding flows change often
QA teams need repeatable walkthroughs
product teams need quick demos
internal tools need documentation too
agents can help keep docs closer to the real app

This is not meant to replace human explanation.

It is meant to remove the boring first pass: record the flow, describe the steps, build the video, repeat when the UI changes.

The stack:

Playwright
Piper, ElevenLabs or OpenAI for TTS
FFmpeg
Vite and React for optional docs site

I am interested in feedback from people maintaining product docs.

Would you trust generated video docs if the source flows were committed and repeatable?

Safer browser automation with a Puppeteer MCP server

Manuel Bruña — Fri, 05 Jun 2026 21:06:33 +0000

Browser automation is one of the most useful abilities for AI agents.

It is also one of the easiest places to make a mess.

A browser tool can click, fill forms, run JavaScript, capture pages and move through real user flows. That power needs boundaries.

That is why I built a Puppeteer MCP server with safety controls in mind.

Repo:
https://github.com/tecnomanu/puppeteer-server

What it supports:

real browser navigation
screenshots
element clicks
form filling
JavaScript evaluation
console log capture
configurable launch options
domain allowlists
rate limits
timeouts
audit logging

For agent workflows, I think the main question is not just can the agent browse?

The better question is: can it browse inside explicit limits?

A browser MCP server should make unsafe behavior harder by default.

Useful cases:

QA checks
scraping allowed pages
internal admin workflows
visual inspection
automation prototypes
agent-driven browser tasks

I am interested in feedback from people building MCP tools.

Which browser permissions should be default-off?

And what security controls should every browser automation MCP include?

What I learned shipping a real ChatGPT App to the app directory

Manuel Bruña — Fri, 05 Jun 2026 21:04:55 +0000

We shipped the Bytetravel app to the ChatGPT app directory.

That sounds like an integration task. It was not only that.

The technical part mattered, of course. Tools need schemas, responses, validations and reliable backend behavior.

But the hardest part was product design inside a conversation.

A ChatGPT App needs clear answers to questions like:

when should ChatGPT call the tool?
what should the user see after the tool runs?
how much context should the app return?
how do you avoid vague or over-broad results?
how do you test natural language flows?

For travel, this matters a lot. People do not always know if they need travel insurance, eSIM data, visa help, airport lounges or another travel service.

The goal was simple: let someone solve concrete travel needs from a natural conversation.

The path took iterations, reviews, testing, feedback, corrections and resubmissions.

My biggest takeaway: building a ChatGPT App is closer to designing a product surface than exposing an API.

You need engineering, UX thinking, prompt behavior testing and a lot of edge-case work.

I am working as Tech Lead on Globely at Bytetravel, and this process changed how I think about AI products.

If there is interest, I can write a deeper technical breakdown of the app review process, tool design and testing workflow.

AGENTS.md is useful, but project context needs a shared home

Manuel Bruña — Fri, 05 Jun 2026 21:03:41 +0000

Every AI coding tool wants project context.

Claude Code has its files. Cursor has rules. Codex reads AGENTS.md. OpenCode and Windsurf have their own conventions too.

Those files help. The problem starts when the same project facts get copied everywhere.

One stack change lands in one file. Another file stays old. One agent learns the project. Another starts from stale context.

That drift is what Agent Project Context tries to reduce.

APC proposes one repo-owned context layer in .apc/.

It can hold project metadata, agent definitions, reusable skills, curated memory and MCP registry hints.

It should not hold private chats, raw sessions, secrets or runtime state.

AGENTS.md is still useful. APC gives larger agent workflows more structure around it.

MCP connects agents to external tools. APC describes durable project context.

Different layers. Useful together.

Docs:
https://agentprojectcontext.com/

Repo:
https://github.com/agentprojectcontext/agentprojectcontext

If you use multiple AI coding tools in the same repo, I would like feedback.

What should be shared context, and what should stay tool-specific?

Local, private background removal without uploads

Manuel Bruña — Fri, 05 Jun 2026 21:00:32 +0000

I wanted a background-removal workflow that did not depend on a cloud service.

No account. No upload. No API bill. No monthly limit. Just run it locally and process images on your own machine.

So I built Remove Background Local:

https://github.com/tecnomanu/remove-background-local

What it does

Drag and drop images in a web UI
Paste images from the clipboard
Process multiple files in a queue
Keep results in persistent local sessions
Download PNG, WEBP or JPG
Choose transparent or solid-color backgrounds
Run from the CLI with rm-bg
Open it as a small desktop app with Electron
Switch between several segmentation models
Use alpha matting for harder edges like hair, plants or semi-transparent details

The default model is ISNet, because it is fast and good enough for most cases. For higher quality, the app also includes BiRefNet models.

Why local-first matters

Background removal often involves product photos, client assets, design drafts or personal images.

For that kind of work, local processing is not only convenient. It is also a better default:

private by design
no vendor lock-in
no rate limits
no image upload
no hidden cost per batch

Try it

If you already have Node.js and Python 3.9+ installed:

npx -y remove-background-local

Then open:

http://127.0.0.1:7860

For a permanent install:

npm install -g remove-background-local
rm-bg web
rm-bg desktop

Feedback I am looking for

I would especially like feedback from people who work with:

ecommerce images
design workflows
AI image tooling
local-first apps
privacy-sensitive media workflows

If you try it, I would love to know which model gives you the best quality/speed tradeoff on your machine.

Repo:
https://github.com/tecnomanu/remove-background-local

npm:
https://www.npmjs.com/package/remove-background-local