DEV Community: Miller Correa

DeepSeek Harness: el harness abierto que hace lo que Claude Code no te deja tocar

Miller Correa — Wed, 02 Sep 2026 01:19:18 +0000

Los agentes de código son todavía una tecnología relativamente nueva. Y aun así, casi todos venimos de la misma experiencia: abres Claude Code (o cualquier otro), le pides algo, y en el momento en que algo sale mal… estás mirando una caja negra.

¿Por qué falló?
¿Fue el tool? ¿Fue el modelo? ¿Fue tu prompt?
¿En qué turno exacto se torció todo?
¿Y por qué no puedo cambiarle ni el color a esta interfaz?

Si alguna vez te hiciste esas preguntas, este post es para ti. Porque DeepSeek Harness responde las cuatro — y la última de una forma que va a cambiar cómo piensas lo que un "harness de agentes" puede ser.

Spoiler: no es "otro Claude Code". Es otra categoría. Y es open source (MIT).

Qué es DeepSeek Harness

DeepSeek Harness (dsh) es un harness de agentes basado en plugins. No es una app monolítica: es un runtime sobre Cordis, un framework de plugins, donde absolutamente todo es un plugin:

las tools (bash, filesystem, search, web, ask-user, skills…)
el loop del agente y el sistema de goals
el sandbox y la política de permisos
la UI del navegador (tema, layout, sidebar, renderer, marca)
la orquestación (workflows, subagentes, Ralph)
hasta el medidor de tokens y la compactación de contexto

Se arranca igual de fácil que cualquier CLI:

dsh web                            # interfaz web completa
dsh --profile headless "corre los tests"   # one-shot, headless
dsh --profile <mi-perfil>          # tu propio perfil

Lo importante no es cómo se arranca, sino lo que esa arquitectura te permite hacer. Vamos a ello.

1. Observabilidad: sabes exactamente dónde falló (tool, modelo o usuario)

Esta es, para mí, la killer feature. Y la razón por la que lo llamo "disruptivo" sin exagerar.

DeepSeek Harness tiene una vista llamada Trajectory: un ledger de eventos por turno donde puedes seleccionar registros de User, Assistant, Tool y Subtool anidados. Por cada evento ves:

timing real: cuánto fue TTFT (time-to-first-token) y cuánto fue decoding (con hover para el reloj exacto)
tokens consumidos por evento
input / output completo de cada tool call
las fronteras de turno y de step bien marcadas

Traducción práctica: cuando un run se descarrila, no adivinas. Sigues la traza y ves si el problema fue un tool que devolvió basura, un turno del modelo que alucinó, o tu prompt que estaba mal formulado. La responsabilidad queda atribuida, no diluida.

Y esto no es solo cosmética: los errores son estructurados y legibles. Cuando algo se bloquea, el harness no te suelta un stderr críptico. Te dice exactamente qué pasó:

[exit code: 1]
[sandbox: file access denied under workspace-write mode]
[status: running]  →  [status: complete]

Ese último patrón es clave para lo que viene. Porque una denegación no es un muro: es información accionable.

2. Hardened de verdad: sandbox duro, y aun así no te frena

Aquí es donde mucha gente se equivoca con los agentes. Piensan que "seguro" significa "capado". DeepSeek Harness demuestra lo contrario.

Puedes endurecerlo tanto como quieras:

Sandbox por modos, en cada call: read-only, workspace-write y danger-full-access. El agente arranca confinado al workspace y a los directorios temporales, y nada más.
Sandbox de bash a nivel kernel (Seatbelt / Landlock), no solo una validación en el proceso.
Política de aprobación ask: los permisos sensibles piden confirmación humana, con presets de permisos configurables.
Skills limitantes: instrucciones reutilizables que puedes cargar para acotar el comportamiento del agente (sus reglas, sus límites, su "personalidad" operativa).

Lo brutal es que, dentro de ese régimen endurecido, el agente sigue logrando las cosas. ¿Por qué? Porque la denegación es legible y recuperable: el agente ve el marcador [sandbox: file access denied under workspace-write mode], entiende exactamente qué pidió y qué se le negó, y pide un único reintento con el modo más amplio justo y necesario — no abre la compuerta entera.

Es la diferencia entre "caja negra que a veces se atasca" y "sistema confinado que te explica qué necesita y por qué". Para una empresa, eso es auditabilidad. Y la auditabilidad es lo que te deja dormir tranquilo.

3. Intervenir en el "look" del Agent (sí, de verdad)

Esto es lo que Claude Code literalmente no te deja tocar. La UI de DeepSeek Harness también es un conjunto de plugins (client-ui-*): tema, layout, sidebar, renderer de mensajes, marca, ajustes, todo.

¿Qué significa en la práctica?

Re-branding total: ¿quieres que el agente se llame como tu producto y lleve tus colores? Se puede. Es un plugin de UI, no un "dark mode".
Tematización y layout a tu gusto, no al del vendor.
HMR en vivo del client-plugin: editas el plugin de UI y el navegador se recarga sin refresh. Cambias el look del agente mientras lo usas.

Piénsalo en términos de producto: con Claude Code estás dentro de la experiencia que Anthropic decidió darte. Con DeepSeek Harness, la experiencia es tuya. Para una startup que quiere vender un agente embebido o una herramienta interna, esto no es un detalle: es la diferencia entre "usar una app" y "construir sobre una plataforma".

4. Orquestación multiagente de primera clase (no es un afterthought)

Otra cosa que aquí es core y en otros sitios es un parche:

Goals: un objetivo de larga duración event-sourced que persiste en la sesión y permite que el agente continúe de forma autónoma entre rondas (con un cap de rondas configurable). El estado se guarda como eventos en el log de sesión, así que es rejugable y auditable.
Workflow tool: escribes un script JavaScript que fanea el trabajo a decenas de subagentes, con fases y resultados estructurados. Orquestación real a escala.
Ralph: un loop de agentes frescos (cada ronda abre un agente nuevo sin semilla de conversación, usando el workspace como memoria). Ideal para iteración que no quiere arrastrar sesgo de contexto.
Subagentes (subagent y subagent_fork): delegación con o sin herencia de contexto, en background, y con control (send_message, interrupt).

Traducción: el fan-out, la persistencia de objetivos y la iteración multiagente no son hacks. Son herramientas del propio harness.

5. Self-host: tus datos, tus reglas

La agnosticidad de modelo no la voy a vender como novedad — Codex ya lo hacía —; aquí simplemente se mantiene. Lo que sí vale la pena para una empresa es lo demás: lo corres self-host (tus datos, tus llaves, tus logs) y controlas costes con medidor de tokens y compactación configurables.

6. Skills desatadas del proveedor: un plugin para gobernarlas a todas

Hay una consecuencia del diseño por plugins que pocos notan, y para mí es de las más importantes: las skills hoy están secuestradas por cada proveedor.

Las Claude Skills solo viven dentro de Claude Code.
Las skills de Codex solo viven dentro de Codex.
¿Cambias de agente? Pierdes (o tienes que reescribir) toda tu librería de skills.

DeepSeek Harness tiene su propio sistema de skills (dsh-skill), pero lo clave es que, como todo es un plugin, puedes escribir un plugin que interprete los formatos de skills de otros proveedores — Claude Skills, Codex, o los que vengan — y los exponga como skills nativas dentro del mismo harness.

Traducción: tu inversión en skills deja de estar presa de un vendor. Un plugin, y tienes una sola librería de skills, agnóstica de formato, corriendo sobre el modelo que tú elijas. Eso es algo impensable en Claude Code o Codex: son productos cerrados, y ni siquiera tienen un punto de extensión donde enchufar un intérprete de skills ajeno.

La comparación (sin dramatismo)

	DeepSeek Harness	Claude Code
Arquitectura	100% plugins (Cordis): tools, loop, UI, sandbox	Monolito cerrado
Modelo	Agnóstico (se mantiene; Codex ya lo hacía)	Atado a Claude
Observabilidad	Trajectory: User/Tool/Assistant/Subtool, timing TTFT vs decoding, tokens por evento	Caja negra
UI	Plugins tematizables + re-branding + HMR en vivo	Fija, no se toca
Sandbox	Modos por call + bash a nivel kernel + approval `ask`	Limitado
Orquestación	Goals, Workflows, Ralph, subagentes	Mínima
Extensión	Escribes tus propios plugins y perfiles	No extensible
Skills	Plugin compatible multi-formato (Claude, Codex, propios)	Atadas a cada proveedor
Hosting	Self-host, auditable	SaaS

La diferencia de fondo no es "tiene más features". Es una cuestión de filosofía: Claude Code es un producto cerrado que te deja usar. DeepSeek Harness es una plataforma abierta que te deja construir.

Por qué es el mejor harness para compañías y startups

Auditable: sabes qué tool falló, qué modelo se equivocó, qué pidió el usuario. La traza está ahí, atribuida.
Endurecible: sandbox duro + approval, sin sacrificar productividad. Seguridad que no frena.
Personalizable: re-brandea la UI, escribe tus propios tools/skills/plugins. Tu producto, no el del vendor.
Composable: orquestación multiagente como primitiva de primera clase.
Portable: tus skills no quedan atadas a un proveedor; un plugin las unifica (Claude, Codex, propios).
Controlable: self-host + medidor de tokens = dueño de tus costes y tus datos.

Para una startup, esto es la diferencia entre alquilar una herramienta y poseer una ventaja competitiva. Para una empresa, es la diferencia entre "adoptar una IA opaca" y "gobernar una IA auditada".

El punto

DeepSeek Harness todavía está en release candidate (0.1.x), y no te voy a vender que es perfecto. Pero su apuesta arquitectónica es la correcta: abierto, observable, endurecible y re-brandeable. Es exactamente lo que un harness de agentes debería ser en 2026, y lo que los productos cerrados no pueden —ni quieren— ofrecerte.

Si estás construyendo algo con agentes, hazte una pregunta honesta: ¿quieres estar dentro de la caja negra de otro, o quieres una caja que puedas abrir, auditar y hacer tuya?

Yo ya elegí. 🚀

¿Has probado DeepSeek Harness? ¿O vienes de la frustración de no poder tocar tu agente actual? Cuéntamelo en los comentarios.

¿Tu agente puede reescribir su propio plan? Ownership determinista con DeepSeek Harness

Miller Correa — Sun, 23 Aug 2026 03:43:46 +0000

¿Alguna vez le pediste a un agente una tarea concreta y, a mitad de camino, cambió el plan en silencio — re-escribió sus propios objetivos, se salió del alcance, o te "confirmó" que había hecho algo que en realidad había descartado?

En el post anterior sobre agnosticBrain hablamos del conocimiento: la IA sobrescribiendo notas que refinaste a mano. Aquí el problema es distinto pero espejo: el agente sobrescribiendo su propio plan de ejecución. Y hoy por fin lo resolvemos de forma determinista, no aspiracional, gracias a DeepSeek Harness y a un plugin que construimos: @macorreag/dsh-todo-hardened.

El contexto: la lista de tareas siempre fue del agente

Todos los asistentes de código tienen algún mecanismo de tareas: TodoWrite en Claude Code, las task lists de Codex y Cursor, los todos de OpenCode. Funcionan, pero comparten un defecto estructural: la lista es propiedad del agente. El modelo la escribe, la edita y la completa como quiere, y la única barrera es un prompt que dice "mantén la lista actualizada".

Eso no es una garantía, es una sugerencia. Tres limitaciones que nos cansamos de sufrir:

Es disciplina de prompt, no enforcement. Si el modelo deriva, re-encuadra el objetivo o se distrae, la lista lo acompaña. Nadie lo impide.
No hay capa humana inviolable. No existe un "esto lo decidió el humano y tú no lo tocas". Todo lo que el agente ve, el agente lo puede mutar.
La "aprobación" no existe como mecanismo. A lo sumo el agente te dice "¿te parece si hago X?" y luego él mismo reporta que lo hizo. La confirmación humana real, si existe, es externa y manual.

El resultado es un agente que se auto-gobierna su propio contrato. Y un contrato donde una de las partes puede reescribirlo unilateralmente no es un contrato.

El GAP: faltaba ownership para el estado de ejecución

En agnosticBrain resolvimos esto para el conocimiento con una tercera capa: curated/, inviolable para el LLM. El insight era simple y profundo:

El LLM propone. El humano decide. Nadie sobrescribe curated/ sin aprobación humana.

El GAP que quedaba abierto era llevar esa misma jerarquía al plan de trabajo del agente. Porque un agente no solo lee y escribe notas: decide, prioriza, completa y descarta tareas. Y si su lista de tareas no tiene la misma protección que curated/, entonces la parte más crítica de la ejecución — qué se decidió hacer — sigue siendo maleable.

La solución: `dsh-todo-hardened`, ownership para el todo-list

Construimos un plugin para DeepSeek Harness que replica el patrón de agnosticBrain, pero sobre la lista de tareas del agente. Tres capas de ownership:

Capa	Dueño	Quién muta	Regla crítica
`active/`	Agente	Agente (CRUD + finalizar) y humano	Trabajo en curso
`locked/`	Humano	Solo humano	Inviolable para el agente
`archive/`	Sistema	Nadie	Append-only: solo se entra

La clave es locked/: cuando un humano cura una tarea (la bloquea), el agente no puede modificarla. Punto. Y esto no es una regla escrita en un prompt — es una FSM de estados + validación de schema + ownership que corre como gate mecánico antes de cada mutación.

Las reglas no son disciplina de prompt; se aplican mecánicamente en el plugin, igual que curated/ en agnosticBrain.

Si el agente quiere cambiar una tarea bloqueada, no la toca: propone.

El flujo: proponer, no imponer

Cuando el agente necesita modificar algo que está en locked/, la única vía es una propuesta:

El agente crea una propuesta (todo_propose) sobre la tarea bloqueada: kind=update | complete | cancel.
La propuesta queda en estado open — no aplica nada.
El humano la aprueba (todo_approve) o la rechaza (todo_reject).
Solo la aprobación humana aplica el cambio sobre locked/.

Y aquí está lo que "otros nos limitaban": la aprobación es real. No es el agente preguntando y auto-respondiéndose. Las acciones humanas (todo_lock, todo_unlock, todo_approve, todo_reject) pasan por el approval seam del harness (ctx.approval.request), que muestra una UI de confirmación y concede allowed-once:

Sin canal de aprobación disponible, la acción falla cerrada. Un subagente no puede autorizarlas. Nadie aprueba por delegación.

Un rastro real, no un diagrama

Esto no es un whiteboard. Es el log append-only del plugin corriendo en una sesión real (cada operación registra su actor):

agent  | add        t-… → active
human  | lock       t-… → locked
agent  | propose    p-… target=t-… kind=update
human  | approve    p-… → aplica el cambio
agent  | propose    p-… target=t-… kind=complete
human  | reject     p-… → no se aplica
agent  | propose    p-… target=t-… kind=update
human  | approve    p-… → aplica
human  | unlock     t-… → active

El agente intentó completar la tarea; el humano lo rechazó; el agente reformuló la propuesta; el humano la aprobó. Todo quedó registrado, con actor y timestamp, en un log.md que es append-only. El agente puede intentar cualquier cosa, pero no puede modificar locked/ sin que quede un rastro y sin que un humano abra la puerta.

Por qué esto era imposible antes de DeepSeek Harness

El patrón no es nuevo: la idea de "humano decide, agente propone" ya la teníamos en agnosticBrain. Lo nuevo es que DSH expone los primitivos necesarios para hacerlo mecánico, en vez de dejarlo a la buena fe del modelo:

Sistema de plugins (Cordis) donde un paquete puede registrar tools y instalar un hook tools.guard que rechaza write/edit/bash directos sobre todo/. La única vía de escritura son las tools todo_* (que están gated) o el panel humano.
Un approval seam de verdad (ctx.approval.request) con UI, allowed-once y fail-closed. No es "el modelo dice que aprobó": es el harness el que pide y registra la confirmación.
Política de sandbox por sesión, de modo que cada sesión escribe en su propio <workspace>/todo/ — resuelto por ejecución, no con un cwd global frágil.

En otros harnesses, para lograr esto tendrías que reimplementar el seam de aprobación y el guard a mano, y aún así no tendrías dónde anclarlos de forma durable. Aquí es un plugin npm que se declara en una composición y sobrevive a reinicios.

La conexión con agnosticBrain

Lo lindo es que no inventamos una filosofía nueva: es la misma, aplicada a otro dominio.

Dominio	agnosticBrain	dsh-todo-hardened
Qué protege	Conocimiento refinado a mano	El plan/estado de ejecución
Capa inviolable	`curated/`	`locked/`
Mecanismo	`/propose` → aprobación	`todo_propose` → aprobación
Garantía	El LLM nunca sobrescribe	El agente nunca muta sin humano

Antes protegíamos lo que sabes. Ahora protegemos lo que decidiste que se haga.

En resumen

Los agentes son poderosos, pero un agente que es dueño absoluto de su propia lista de tareas es un agente que puede re-negociar el contrato contigo a espaldas tuyas. Con DeepSeek Harness y dsh-todo-hardened, por fin convertimos el "debería respetar el plan" en "no puede modificarlo sin que tú lo apruebes".

El agente propone. El humano decide. Y ahora, de verdad, es imposible lo contrario.

Si quieres verlo: el plugin está en github.com/Macorreag/dsh-todo-hardened (npm @macorreag/dsh-todo-hardened, MIT), y la filosofía que hereda, en github.com/Macorreag/agnosticBrain.

¿alguna vez un agente te reescribió el plan a mitad de una tarea, lo detectaste?

¿La IA está sobrescribiendo tus notas? Tres capas de ownership para proteger tu conocimiento

Miller Correa — Sat, 22 Aug 2026 00:46:19 +0000

¿Alguna vez refinaste una nota durante horas — redactando, puliendo, dándole estructura — y un ingest posterior la sobrescribió silenciosamente, como si tus horas nunca hubieran existido?

Si usas LLMs para mantener una base de conocimiento, probablemente ya sentiste ese dolor: la IA genera contenido excelente, pero cuando tú lo mejoras a mano, no siempre respeta tus ediciones. Este artículo te muestra cómo resolvimos ese problema en agnosticBrain, un vault de conocimiento basado en el patrón LLM Wiki de Andrej Karpathy, al que agregamos tres capas de ownership en lugar de las dos originales.

El contexto: LLM Wiki, la propuesta de Karpathy

En abril de 2026, Andrej Karpathy publicó su gist sobre LLM Wiki, una idea elegante para bases de conocimiento personales:

The wiki is a persistent, compounding artifact. The cross-references are already there. The contradictions have already been flagged. The synthesis already reflects everything you've read.

La idea: en lugar de RAG clásico (recuperar fragmentos crudos en cada consulta), el LLM compila y mantiene una wiki persistente — un conjunto de notas markdown interconectadas que vive entre tú y tus fuentes. Obsidian es el IDE, el LLM es el programador, y la wiki es el código.

La arquitectura tiene dos capas:

raw/ — Tus fuentes crudas. Inmutables. El LLM solo lee.
wiki/ — Conocimiento compilado. El LLM lo escribe y mantiene todo. Tú lo lees.

Suena perfecto, ¿no? El LLM hace todo el trabajo pesado. Pero hay un punto ciego.

El GAP: el conocimiento refinado a mano no estaba protegido

El patrón de Karpathy asume que tú nunca escribes en la wiki — el LLM la mantiene por completo. En la práctica, eso no se sostiene. Eventualmente quieres intervenir: corregir una síntesis, afinar una conclusión, documentar algo que aprendiste por experiencia y que ninguna fuente captura.

¿Y qué pasa entonces?

Los sistemas de conocimiento con IA tienen un punto ciego: no distinguen entre conocimiento generado automáticamente y conocimiento refinado por el humano. El LLM, durante un ingest o lint, puede sobrescribir silenciosamente ediciones manuales que costaron horas construir.

Si editas wiki/ a mano, estás editando un archivo que el LLM considera suyo. El próximo ingest puede sobrescribirlo, exactamente como tu compilador regeneraría un archivo generado.

Ese es el único GAP que reconocemos en la propuesta de Karpathy, y es justo el que resolvimos en agnosticBrain.

La solución: tres capas de ownership

En lugar de dos capas, agnosticBrain define cuatro directorios con dueños explícitos y reglas no-negociables:

Directorio	Quién escribe	Quién lee	Regla crítica
`raw/`	Humano	Todos	LLM nunca modifica
`wiki/`	LLM	Todos	El humano no edita a mano
`curated/`	Humano	Todos	LLM NUNCA modifica
`archivo/`	Sistema	Todos	Solo se entra, orden del humano

La clave es la tercera capa: curated/ — notas refinadas manualmente, sagradas, de solo lectura para cualquier agente. La regla es contundente:

REGLA 1 — El contenido de curated/ es inviolable. NUNCA editar, sobrescribir ni alterar el contenido de una nota que reside en curated/. Esta prohibición de contenido no tiene excepción: no se negocia en ingest, lint, ni ninguna otra operación de conocimiento.

Si lo editaste a mano y no quieres perderlo → va en curated/, no en wiki/.

Cómo congelar una nota: `/curate`

Para proteger una nota que refinaste, el flujo es simple. La mueves de wiki/ a curated/ con la operación /curate, y a partir de ese momento el LLM no la puede modificar:

Verificar que la nota está en wiki/ y confirmar que quieres congelar su estado actual.
En tus propias palabras — única fricción intencional del pipeline: el humano escribe la idea central de la nota. El LLM nunca redacta ni sugiere esta línea. Es una firma de propiedad humana.
Reescribir el frontmatter al schema de curated/: status: human-canonical, llm_action: read-only, human_curated: true.
Mover la nota a curated/.
Actualizar wiki/index.md (la entrada pasa a marcarse como [CURATED]).
Registrar en wiki/log.md.
Confirmar al humano: "✅ La nota [[curated/…]] está ahora protegida. El LLM no la modificará en futuros ingest ni lint."

Cuando el LLM encuentra información nueva: `/propose`

Aquí está la parte interesante. ¿Qué pasa si el LLM procesa una nueva fuente que debería actualizar una nota curada? ¿Ignora el conocimiento? ¿Lo aplica en secreto?

Ninguna de las dos. La REGLA 6 lo resuelve:

REGLA 6 — Proponer, no imponer, sobre curated/. Si información nueva actualiza o contradice curated/<nota>: → Crear wiki/_proposed/YYYY-MM-DD-<nombre-nota>.md con el diff propuesto. → Nunca tocar la nota curada.

El flujo, definido en SKILLS/propose.md, es el siguiente:

Identificar la nota curada afectada y leerla completa.
Construir el diff propuesto — solo la sección afectada, no el archivo completo. Formato: sección actual (cita verbatim) → propuesta de cambio (solo el delta) → justificación.
Crear la propuesta en wiki/_proposed/YYYY-MM-DD-<nota>.md.
Actualizar el index (sección "Propuestas pendientes").
Registrar en wiki/log.md.
Notificar al humano: "⚠️ Información nueva relevante para curated/. Creé una propuesta. Cuando quieras, te muestro el diff o lo aplico si lo apruebas."

El nombre del directorio lo dice todo:

El LLM propone. El humano decide. Nadie sobreescribe curated/ sin aprobación humana.

Esto es lo que llamamos el mecanismo que cierra el loop de aprendizaje sin sacrificar la protección del conocimiento curado. El LLM puede seguir aprendiendo de nuevas fuentes, pero nunca actúa unilateralmente sobre lo que tú construiste.

Cómo se cierra el loop: la aprobación humana

Cuando quieres aceptar una propuesta, solo dices algo como:

"Aplica la propuesta de _proposed/YYYY-MM-DD-<nota>.md"

Y el LLM:

Lee la propuesta completa.
Lee la nota curada completa.
Aplica SOLO el delta propuesto — nada más.
Actualiza last_human_edit (aunque fue el LLM quien lo aplicó, es una edición aprobada por el humano).
Marca la propuesta como aplicada y actualiza el index.
Registra proposal-applied en el log.

Incluso en la aprobación, la protección no es un candado: es un límite de permisos donde solo una decisión humana explícita puede abrir la escritura.

El resto del sistema

agnosticBrain no es solo ownership. Tiene nueve operaciones definidas en el kernel (AGENTS.md):

Operación	Invocación	Qué hace
`/ingest`	`/ingest [fuente]`	Compila una fuente en átomos enlazados
`/query`	`/query [pregunta]`	Consulta navegando por MOCs y enlaces tipados
`/lint`	`/lint`	Health-check + salud del grafo
`/archive`	`/archive [nota]`	Mueve nota a `archivo/` — solo por orden explícita
`/curate`	`/curate [nota]`	Congela nota de `wiki/` a `curated/`
`/propose`	Auto durante ingest	Crea propuesta de cambio para nota curada
`/status`	`/status`	Dashboard: conteos, log, propuestas pendientes
`/gaps`	`/gaps`	Absorbe brechas respondidas (feedback loop)
`/compose`	`/compose [--hasta-limpio]`	Composición autónoma continua del grafo

Y un principio de diseño que nos gusta especialmente (REGLA 8): una nota = un átomo; el cerebro es una red, no un archivador. Cada /ingest mejora el grafo — más nodos, mejores enlaces, menos centralización — en vez de engordar pocas notas gigantes. El cerebro compone, no acumula.

Todo en texto plano: markdown puro, sin dependencias de apps. Solo necesitas Obsidian (con Templater) y el kernel en AGENTS.md — un archivo que leen sin transformación los agentes (Claude Code, Codex, Cursor).

En resumen

Karpathy nos dio un patrón brillante para que el LLM compile tu conocimiento en una wiki persistente. Pero le faltaba responder una pregunta: ¿qué pasa cuando tú también escribes?

Nuestra respuesta fue una tercera capa de ownership + un mecanismo de propuesta que respeta la jerarquía natural: el LLM propone, el humano decide. Con eso el conocimiento refinado a mano se vuelve inviolable, y el aprendizaje no se detiene — simplemente pasa por aprobación humana.

Si quieres ver la implementación completa — con los 9 skills, los scripts de verificación y las reglas del kernel — está todo en github.com/Macorreag/agnosticBrain. Y la propuesta original que extendemos, en el gist de LLM Wiki de Karpathy.

Esperamos que este patrón te sea de gran utilidad en tu flujo de conocimiento. ¿tu LLM ha sobrescrito alguna vez una nota que cuidaste a mano?

Conecta Notion y AI en n8n: ¡Adiós API, hola MCP OAuth2!

Miller Correa — Thu, 20 Nov 2025 05:06:40 +0000

¿Alguna vez has soñado con decirle a tu automatización: "Oye, revisa mi base de datos de Notion y resume las tareas pendientes de esta semana" y que simplemente... lo haga? 🤯

Sin configurar docenas de nodos HTTP. Sin pelearte con la documentación de la API de Notion para ver cómo filtrar por fechas. Solo tú, tu agente de IA y tus datos.

Bueno, tengo noticias increíbles. El mundo del Model Context Protocol (MCP) ha llegado a n8n con una actualización que estábamos esperando: Soporte nativo para OAuth2.

Hoy vamos a ver cómo conectar el servidor oficial de Notion MCP directamente en n8n. ¡Prepárate para darle superpoderes a tus workflows! 🚀

¿Qué es esto y por qué debería importarme?

Para los que no están al tanto, MCP es como un estándar universal (imagina un puerto USB-C) para conectar modelos de IA con fuentes de datos. Antes, si querías que ChatGPT o Claude interactuaran con Notion dentro de n8n, tenías que crear herramientas personalizadas complejas.

El problema anterior:

Conectar servidores MCP remotos seguros requería configuraciones extrañas o proxies porque la autenticación era un dolor de cabeza.

La solución actual:

n8n ha lanzado el soporte para MCP Client OAuth2 API. Esto significa que puedes usar el servidor oficial de Notion (https://mcp.notion.com/mcp) y autenticarte con el botón de "Conectar cuenta" de toda la vida.

¿Por qué esto es mejor que usar el nodo tradicional de Notion?

Lenguaje Natural: No necesitas configurar parámetros rígidos. La IA "lee" la estructura de tu Notion y decide qué hacer.
Velocidad de desarrollo: Te ahorras horas definiendo funciones. Conectas el MCP y la IA ya sabe cómo crear páginas, leer bases de datos o buscar contenido.
Seguridad: Usamos OAuth2 estándar. Nada de tokens pegados en texto plano donde no deben estar.

Tutorial: Conectando Notion vía MCP en n8n

¡Manos a la obra! Vamos a configurar esto en menos de lo que tardas en tomarte un café. ☕

Requisitos previos

Una instancia de n8n actualizada (asegúrate de tener las últimas versiones que soportan MCP Auth).
Una cuenta de Notion.

Paso 1: El Nodo Mágico

Necesitamos usar el nodo MCP Client Tool. Este nodo es el puente que le dice a tu Agente de IA (como el nodo AI Agent) qué herramientas tiene disponibles.

Busca en tu n8n: MCP Client Tool (asegúrate de que sea la versión de LangChain).

Paso 2: Configuración de Credenciales (El Truco Pro)

⚠️ Tip de Experto: A veces, la opción para crear la credencial no aparece correctamente si intentas hacerlo directamente desde el nodo. Para evitar dolores de cabeza, vamos a crearla primero desde el gestor de credenciales.

En el menú lateral izquierdo de n8n, ve a Credentials.
Haz clic en Add Credential y busca MCP OAuth2 API.
Rellena los datos necesarios:
- Server URL: https://mcp.notion.com/mcp
- Configura el OAuth2 estándar (Client ID, Client Secret, Auth URL, Token URL) según la documentación de tu integración de Notion, o usa la configuración dinámica si está disponible.
- Asegúrate de copiar el OAuth Redirect URL de n8n (https://oauth.n8n.cloud/oauth2/callback) y ponerlo en tu integración de Notion si estás usando una app personalizada.

(Así se ve cuando la conexión es exitosa, ¡luz verde!)

Guarda la credencial.
Ahora sí, vuelve a tu nodo MCP Client Tool, selecciona mcpOAuth2Api en Authentication y elige la credencial que acabas de crear de la lista.

Paso 3: El Código (Copy & Paste)

Para hacértelo aún más fácil, aquí tienes el JSON del nodo listo para importar. He limpiado los datos sensibles para que sea seguro usarlo.

Simplemente copia esto, pégalo en tu lienzo de n8n y ajusta las credenciales seleccionando la que creaste en el paso anterior:

{
  "nodes": [
    {
      "parameters": {
        "endpointUrl": "https://mcp.notion.com/mcp",
        "authentication": "mcpOAuth2Api",
        "options": {}
      },
      "id": "YOUR_NODE_ID",
      "name": "Notion MCP Client",
      "type": "@n8n/n8n-nodes-langchain.mcpClientTool",
      "typeVersion": 1.2,
      "position": [
        1000,
        500
      ],
      "credentials": {
        "mcpOAuth2Api": {
          "id": "YOUR_CREDENTIAL_ID",
          "name": "MCP Notion Account"
        }
      }
    }
  ],
  "connections": {
    "Notion MCP Client": {
      "ai_tool": [
        []
      ]
    }
  },
  "pinData": {}
}

Paso 4: ¡A probar!

Conecta este nodo a un AI Agent (como el que usa OpenAI o Anthropic). En el chat del agente, simplemente escribe:

"Por favor, crea una nota en mi página de 'Ideas' que diga 'Investigar más sobre MCP en n8n' y ponle fecha de hoy."

¡La IA usará la herramienta MCP, se autenticará vía OAuth2, entenderá tu estructura de Notion y ejecutará la acción sin que tú hayas configurado un nodo de "Create Page"! ✨

Conclusión: El futuro es conversacional

Esta actualización de n8n nos acerca un paso más a un futuro donde no programamos cómo suceden las cosas paso a paso, sino que definimos qué herramientas tiene la IA y dejamos que ella haga el trabajo pesado.

La integración nativa de Notion MCP elimina la fricción técnica. Ya no hay excusas para no tener un asistente personal que realmente gestione tu vida digital.

¿Y tú? ¿Qué vas a automatizar primero con Notion y MCP? ¡Déjame tus ideas en los comentarios! 👇

Happy automating! 🤖💙, obviamente una IA me ayudo a escribir esto!

Compartiendo modificaciones de código Sin Internet: La Utilidad del Git Patch

Miller Correa — Mon, 09 Jun 2025 03:59:43 +0000

¿Alguna vez te has encontrado en la situación de querer compartir cambios específicos en archivos de código con un colega, pero sin la posibilidad de subir esos cambios a un repositorio o sin acceso a internet?. Ya sea para probar una funcionalidad con un mock, realizar validaciones temporales o simplemente para tener esos ajustes a mano para un uso futuro, la opción tradicional de git stash a veces no es suficiente, especialmente si quieres compartirlos.
Si necesitas compartir esos cambios con tu equipo sin depender de un repositorio remoto o una conexión a internet, este artículo te mostrará cómo git patch se convierte en tu aliado. Exploraremos cómo crear y aplicar parches de manera efectiva, una solución robusta para la transferencia de código en escenarios específicos.

¿Qué es un 'Patch' en Git y Por Qué Deberías Usarlo?

Es un documento de texto plano que contiene las indicaciones precisas de los cambios que deben realizarse sobre líneas específicas de archivos. Esta característica es fundamental en Git, ya que el sistema se encarga de rastrear cada cambio y construir un "historial" que permite obtener una versión actualizada de cada archivo.
Su utilidad principal radica en la capacidad de:

Transferir cambios sin conexión: Ideal para entornos con conectividad limitada o nula.
Compartir ajustes específicos: Permite aislar cambios para pruebas o revisiones sin afectar ramas principales.
Controlar lo que se comparte: A diferencia de un commit o un push, puedes seleccionar exactamente qué modificaciones incluir en el parche.

Git Patch: Cómo Compartir Cambios de Código sin Necesidad de Internet ni Repositorios Remotos

¿Te has encontrado en la situación de necesitar compartir rápidamente modificaciones en tus archivos de código con un compañero, pero sin la posibilidad de usar un repositorio remoto o una conexión a internet? O quizás, ¿buscas una manera de guardar cambios específicos para pruebas temporales, como usar un mock o quitar validaciones, sin que queden registrados en una rama o subirlos al repositorio? Los parches de Git ofrecen una solución elegante y eficiente para estos escenarios, permitiéndote tener esos cambios "a mano para usar después".

Un parche de Git es un documento de texto plano que contiene las instrucciones precisas para efectuar cambios sobre líneas específicas de archivos. Esta es la esencia de Git, ya que el sistema se encarga de rastrear cada cambio y construir un "historial" que nos permite obtener una versión actualizada de cada archivo.

A continuación, te mostramos cómo crear, transferir y aplicar estos parches de manera sencilla y efectiva.

1. Creación de un Parche (Patch)

Para empezar, navega al directorio de trabajo de tu repositorio en tu terminal.

Para cambios no comiteados ni añadidos al *commit*:
Utiliza el comando git diff para generar un archivo que contenga solo las diferencias no guardadas. Este es ideal para cambios que aún no has decidido guardar en el historial del proyecto.
```
git diff > cambios.patch
```
Este comando creará un archivo llamado cambios.patch con todas las modificaciones pendientes.
Para el commit más reciente:
Si tus cambios ya han sido comiteados y deseas compartir las diferencias de tu último commit, usa git format-patch.
```
git format-patch -1 HEAD
```
Este comando generará un archivo .patch que encapsula todas las diferencias de ese commit.

2. Copia y Transferencia del Archivo de Parche

Una vez que tengas el archivo .patch creado, puedes transferirlo a tu compañero utilizando cualquier método físico. Algunas opciones incluyen:

Copiarlo a una memoria USB.
Enviarlo por correo electrónico si dispones de una conexión temporal.
Utilizar cualquier otro método de transferencia física para llevarlo a tu compañero.

3. ¿Como se usa el parche?

Tu compañero debe seguir estos pasos para aplicar los cambios contenidos en el parche:

Copiar el archivo .patch en su directorio de trabajo del repositorio.
Usar el comando git apply para aplicar los cambios:
```
git apply cambios.patch
```

¡Y listo! Los cambios se aplicarán directamente en los archivos locales de tu compañero, sin necesidad de interacciones con un repositorio remoto o una conexión a internet. Esta es una forma eficiente y práctica de colaborar en el desarrollo de software cuando las condiciones lo requieren.

Esperamos que esta guía te sea de gran utilidad en tu flujo de trabajo como desarrollador. En la comunidad de dev.to, valoramos el intercambio de conocimientos y experiencias entre desarrolladores.

How to use gettext in phoenix?

Miller Correa — Fri, 16 Aug 2024 17:15:00 +0000

Así se usa Gettext:

<h1><%= gettext "Welcome to %{name}!", name: "Phoenix" %></h1>

Errores en Gettext

Extraer las traducciones

mix gettext.extract

Mezclar las traducciones extraídas con las que ya tengo (para todos los lenguajes)

mix gettext.merge priv/gettext

Pluralización

https://phrase.com/blog/posts/i18n-for-phoenix-applications-with-gettext/

Este comando de pluralización genera errores cuando se le pasa un numero menor que 1 ya que no existen plurales para 0 ó numeros negativos y sintacticamente no tiene sentido

Ejemplo

## Llamado de un texto en singular con número 1
<%= ngettext("Total salary", "Total salaries", 1) %> #-> Total Salaries
## Llamado de un texto plural con número 2 ó mas en este caso ese numero se interpola

<%= ngettext("Total salary", "Total salaries", 2) %> #-> Total Salaries

Archivos .po en plural

msgid "Total salary"
msgid_plural "Total %{count} salaries"
msgstr[0] "Total Salary"
msgstr[1] "Total Salaries"

Ventajas de manejar Gettext sin nomenclatura

La traducción al inglés ya está hecha en el código.
El manejo de mayusculas y minusculas no depende de usar prefijos(ejm: Text ó Label), si no de la palabra correspondiente, si se usa una palabra en mayuscula la primera esta va a salir así como se escriba
1. Con Nomenclatura
```
msgid "LabelDeductions"
msgstr "Deducciones"

msgid "textDeductions"
msgstr "deducciones"
```
1. Sin nomenclatura
```
msgid "Deductions"
msgstr "Deducciones"

msgid "deductions"
msgstr "deducciones"
```
Nota:
```
<%= gettext("house") %>
<%= gettext("House") %>
```
Si se tiene lo anterior en el código y se realiza una traducción como
```
msgid "house"
msgstr "casa"
```
Al extraer y mezclar traducciones, Gettext infiere automáticamente la otra traducción sin tener en cuenta las mayúsculas y regresa(con la palabra fuzzy).
```
#, elixir-format, fuzzy
msgid "House"
msgstr "casa"
```
Lo anterior permite que el desarrollador no tenga que estar pendiente de las mayusculas que están en el documento.

Se optimiza el tiempo de codificado, las traducciones se pueden hacer de manera atemporal.

El hecho de ser atemporales y sin contexto se refiere a que “una persona sin tener el contexto ó la información de donde se muestran estos mensajes en la aplicación puede traducirlos ó crear una mejor traduccion.”

msgid "LabelDaysGrantedVacation"
msgstr "Días otorgados de vacaciones"

## Reemplaza con

msgid "Vacation days granted"
msgstr "Días otorgados de vacaciones"

## La traducción en ingles se torna opcional, ya que el usuarió visualizara
## "Vacation days granted" y no "LabelDaysGrantedVacation" al igual que el 
## programador que vera un texto mas entendible

```bash
msgid "TextInfoAbbRUTAbbDIAN"
msgstr "Para ingresar la información personal de su nuevo trabajador, puede ingresar el archivo (PDF) del Registro Único Tributario (RUT) descargado de la DIAN (maximo de treinta días de antiguedad). Recuerde que lo puedes descargar del sistema Muisca de la DIAN "

msgid "To enter the personal information of your new worker, you can enter the file (PDF) of the Single Tax Registry (RUT) downloaded from the DIAN (maximum thirty days old). Remember that you can download it from the DIAN Muisca system "
msgstr "Para ingresar la información personal de su nuevo trabajador, puede ingresar el archivo (PDF) del Registro Único Tributario (RUT) descargado de la DIAN (maximo de treinta días de antiguedad). Recuerde que lo puedes descargar del sistema Muisca de la DIAN "
```

Las variables empiezan a tomar sentido

#Con nomenclatura
msgid "LabelApplyDecree%{Decree}%{YearDecree}"
msgstr "Aplica para decreto %{Decree} del año %{YearDecree}"

#Sin nomenclatura
msgid "Applies to decree %{NumberDecree} of %{YearDecree}"
msgstr "Aplica para decreto %{Decree} del año %{YearDecree}"

Las traducciones se pueden compartir entre proyectos,

El comando mix gettext.merge priv/gettext no borra las traducciones que ya se tienen en el archivo, por el contrario las mezcla é intenta predecir las posibles traducciones, si no tiene una coincidencia perfecta, marca la traducción como "dirtty", una vez que se modifica por parte de un programador manualmente, la establece como limpia automaticamente para la proxima extracción.
Gettext utiliza la distancia de Jaro para determinar si dos palabras o frases son similares y de esta manera infiere la traducción que marca como fuzzy

Plurales, porque complicarse?

Sí, es más complejo usar plurales en forma adecuada en Gettext que utilizar condicionales en elixir y usar:

<%= if numero_casas > 1 %> 
    <%= "Las Casas" %>
<% else %>
    <%= "La Casa" %>
<% end %>

Que usar:

<%= ngettext("La Casa", "Las Casas", numero_casas) %>

Si bien tiene una curva de aprendizaje su uso, el código es más legible y estas traducciones nos serviran en otros proyectos

De esta manera, si algo no funciona siempre va a tener una lectura real y clara

Ventaja traducción con los plurales

Los id singulares son diferenciados de los Id plurales


#Los Id no chocan con los Id plurales
msgid "TextDeductions" #mismo ID en singular
msgstr "deducciones"

msgid "TextDeduction"
msgid_plural "TextDeductions" #mismo ID en plural
msgstr[0] "deduccion"
msgstr[1] "deducciones"

Desventajas

Los plurares NO incluyen el termino que se debe utilizar cuando se tienen 0 items solo cuando se tiene uno ó muchos por ejemplo

Sin filtros # No hay forma de aplicarlo
1 Filtro
2 Filtros
3 Filtros

Los plurales se tornan más largos,

ngettext("Deduction", "Deductions", 2)

Los archivos mezclados primero se deben esx

mix gettext.merge priv/gettext/en/LC_MESSAGES/default2.po priv/gettext/en/LC_MESSAGES/default.po

Mezclar 2 archivos .po

mix gettext.merge  priv/gettext/en/LC_MESSAGES/default2.po priv/gettext/en/LC_MESSAGES/default.po

Para test

<%= gettext("The house is very pretty") %>

<%= gettext("The house") %>

<%= gettext("is very pretty") %>

<%= gettext("is very %{house}") %>

<%= gettext("house") %>

<%= gettext("House") %>

Mayusculas y minusculas

Gettext es CaseSensitive debido a que en algunos lenguajes una palabra en mayuscula es diferente a una palabra en minúscula, por lo tanto tiene esta diferencia y la solucion es tratar ambos casos como corresponde además facilita el trabajo del progrmador, esto es una ventaja y una desventaja en realidad que se soluciona con gettext extract.

Gettext con variables en el string

<% text_action = if @action == "edit", do: "LabelEdit%{Object}" , else: "LabelCreate%{Object}" %>
<span class="uk-text-capitalize uk-font-size-15"><%= Gettext.gettext(WebPortalBillingWeb.Gettext, text_action, Object: gettext("TextClient")) %></span>

Usar Gettext dentro de controladores ó liveview

Es importante pasar *NombreApp**Web**.Gettext en el primer parámetro para que funcione el gettext, tenga en cuent que el módulo es NombreApp**Web** con Web al final.*

Gettext.gettext(NombreAppWeb.Gettext, "LabelRestrictionForDSAdquisitionsNational%{Object}", Object: "#{id_type}")

Usando con un contexto específico “errors” es decir, el archivo errors.po

Gettext.dgettext(NombreAppWeb.Gettext, "errors", "Message")

#Si el mensaje esta en una variable puede definir un valor por defecto con || 
#ya que si pasa nil a la función esta fallara

Gettext.dgettext(NombreAppWeb.Gettext, "errors", (nil || "Default Message")

Como hacer una traduccion con un valor que cambia?

Esto no funciona, nativamente pero se puede intentar sacar las variables aparte con una función para hacer el matching.

Suponga que del back llegan los siguientes errores

"Son 300 pesos" 
"Son 650 pesos" 
"Son 700 pesos"

¿Es posible generar un gettext que traduzca este texto mediante un unico id?

Puede intentar usar named_captures para sacar aparte la lista de numeros que vienen en un texto

Regex - Elixir v1.12.3

#Algo como esto
msgid "Son %{Number} pesos"
msgstr "Is %{Number} pesos"
#generara algo como esto
"Is 300 pesos"


Gettext.gettext(WebPortalBillingWeb.Gettext, "Is 700 pesos")

Ignora archivos solo para ti en Git

Miller Correa — Thu, 20 Jun 2024 13:05:32 +0000

¡Ignora archivos solo para ti en Git: domina .git/info/exclude como un pro!

Ey Devs!, ¿alguna vez han querido excluir archivos de Git solo para su repositorio local sin afectar a sus colaboradores? ¡Entonces .git/info/exclude es su nuevo mejor amigo!

¿Qué es .git/info/exclude?

A diferencia del archivo .gitignore, que se comparte con los colaboradores y se aplica a todos los clones del repositorio, .git/info/exclude es un archivo personal que reside en .git/info/ y solo se aplica a tu clon local. Esto lo convierte en el lugar ideal para omitir archivos que solo son relevantes para tu configuración de desarrollo o que no deseas compartir con el mundo.

¿Cuándo usar .git/info/exclude?

Imagina estos escenarios:

Configuraciones de inicio de sesión personalizadas: Si tu proyecto utiliza archivos de inicio de sesión confidenciales, como .env o .credentials, añádelos a .git/info/exclude para evitar que se confirmen accidentalmente.
Herramientas de desarrollo específicas: ¿Utilizas herramientas que generan archivos temporales en el directorio de trabajo del repositorio? Añádelos a .git/info/exclude para mantener tu espacio de trabajo limpio y sin archivos innecesarios.
Archivos de prueba o borradores: Si tienes archivos de prueba o borradores que no deseas que se incluyan en el historial de Git, .git/info/exclude es tu solución.

¿Cómo usar .git/info/exclude?

Abre .git/info/exclude: Ubicate en la raiz de tu proyecto rastreado por git y ejecuta este comando para usar tu editor de texto favorito para abrir este archivo ubicado en la raíz de tu repositorio Git.

code .git/info/exclude

Agrega patrones de exclusión: Cada línea en .git/info/exclude representa un patrón de archivo que deseas omitir. Git utiliza la sintaxis de exclusión de Git estándar, como comodines y expresiones regulares.
Guarda: Guarda los cambios en .git/info/exclude. ¡Listo! Los archivos que coincidan con tus patrones de exclusión ahora serán ignorados por Git en tu clon local.

Ejemplo:

Para omitir el archivo test.txt de tu repositorio local, agrega la siguiente línea a .git/info/exclude:

test.txt

Recursos adicionales:

Documentación oficial de Git sobre .git/info/exclude: https://git-scm.com/docs/gitignore/
Artículo sobre "Ignorar archivos en Git sin agregarlos a .gitignore": https://stackoverflow.com/questions/653454/how-do-you-make-git-ignore-files-without-using-gitignore

¡Consejo profesional:

Utiliza comentarios en .git/info/exclude para describir los archivos o patrones que estás excluyendo para mejorar la legibilidad y el mantenimiento.

¡Con .git/info/exclude en tu arsenal, puedes mantener tu repositorio local limpio y organizado, sin sacrificar la flexibilidad de excluir archivos específicos para tu configuración de desarrollo!

Google Apps Script - Configuración en Codespaces

Miller Correa — Fri, 01 Mar 2024 13:19:43 +0000

Como usar Google Apps Script en Codespaces

Te presento esta plantilla de Github-Codespaces para que modifiques tus proyectos de Google Apps Script mediante Clasp

https://github.com/Macorreag/clasp-template/tree/main

Configuracion de Clasp en Codespaces

Primero debe logearse en una maquina Linux con el siguiente comando

clasp login

Esto genera un archivo .clasprc.json en la carpeta ./home/name_user/ en sistemas Linux

Default credentials saved to: ~/.clasprc.json (/home/[USER]/.clasprc.json).

Luego debe copiar las credenciales en la ventana de codespaces.

Despues Copie las credenciales al espacio de trabajo hacia la carpeta de usuario del entorno de Codespaces

cp codespaces-blank/.clasprc.json ../../home/codespace/

Una ves realizado esto Clasp utilizará este archivo con el token que contiene para acceder a los archivos de Google Apps Script

Usar multiples archivos de configuración para las credenciales

Github Codespaces permite usar un repositorio de .dotfiles en el cual puedes establecer las credenciales en los archivos .clasprc.json en la ruta ~/ es decir en el directorio raiz. Estos archivos definen las credenciales y cuentas utilizadas para el acceso a los script. Para manejar multiples cuentas puedes crear multiples archivos asi:

clasprc-work.json
clasprc-personal.json

Y finalmente para definir cual usar puedes usar un soft link de Linux forzado para sobreescribir, que apunte a cada uno de los archivos según desees usar:

ln -f -s {source-filename} {symbolic-filename}
ln -f -s ~/.clasprc-personal.json ~/.clasprc.json

Puede chequear que el cambio funciona correctamente con:

$ clasp  login --status
> You are logged in as personal@gmail.com

Clone el Script que necesita mediante

clasp clone "15ImUC************************6qiC" --rootDir .

habilitar Google Apps Script

if errror:
User has not enabled the Apps Script API. Enable it by visiting https://script.google.com/home/usersettings then retry. If you enabled this API recently, wait a few minutes for the action to propagate to our systems and retry.

NO OLVIDE APAGAR SU MAQUINA DE CODESPACEES

In VS Code: open the Visual Studio Code Command Palette - for example, by pressing Ctrl+Shift+Enter(Windows/Linux) or Shift+Command+P (Mac) - type Codespaces: stop then press Enter.
In the JetBrains client, click the stop button at the top of the GitHub Codespaces tool window. For more information, see the "JetBrains IDEs" tab of "Stopping and starting a codespace."
In a terminal window: use the GitHub CLI command gh codespace stop. For more information, see "Using GitHub Codespaces with GitHub CLI." If you exit your codespace without running the stop command (for example, by closing the browser tab), or if you leave the codespace running without interaction, the codespace and its running processes will continue for the duration of the inactivity timeout period.

El enlace para acceder a tus proyectos es:

https://script.google.com/u/1/home/start

La cuenta esta definida por el numero, ahi podras ver los proyectos que tienes actualmente en Google Apps Script.

Configuracion para correr el comando RUN

https://github.com/google/clasp/blob/master/docs/run.md

El contenedor monta en la carpeta superior un proyecto de Node, e internamente coloca los archivos de Google Apps Script

Luego cambia la carpeta donde inicia el contenedor mediante la propieddad de Devcontainers.

💵 ¿Cómo comprar un buen computador?

Miller Correa — Tue, 15 Aug 2023 16:23:14 +0000

Como estudiante de ingeniería de sistemas, a menudo me preguntan ¿cual computador debo comprar? ó ¿ Cual computador de estos es mejor ? y la respuesta no solamente depende de las características del computador en si, sino que también depende de aspectos muy subjetivos como quien lo va a usar etc..

¿Quién lo va a usar?

[ ] ¿Niños?
[ ] ¿Jóvenes?
[ ] ¿Personas mayores?

¿Para que lo va a usar?

[ ] Trabajo (Office, Word y Internet ).
[ ] Herramientas de diseño de Adobe como photoshop.
[ ] Juegos de alto rendimiento.
[ ] Solo navegar en internet.

¿ Sistema Operativo?

[ ] Windows 10 (Excel, Word ...)
[ ] Windows 7 (Excel, Word ...)
[ ] Distribuciones Linux como Ubuntu

¿Que programas usan ?

¿Almacenamiento SSD ó Disco Magnético?

SSD
- Mayor velocidad si se tiene buen procesador.
- Menor capacidad de almacenamiento.
- Es mejor para computadores portátiles [ ya que se puede mover cuando este prendido y que no se dañe el mismo ]
Disco Magnético
- Menor Velocidad según procesador.
- Muchísima capacidad de almacenamiento.
- Muy susceptible a daños cuando se cae ó el computador se mueve mucho.

¿Tiene que ser un computador portátil?

¿ Va a usar Wifi o estará conectado mediante cable Ethernet?

¿Que prefiere?

[ ] Bonito y liviano pero lento.
[ ] Liviano y un poco lento además se puede calentar.
[ ] Rápido, no muy bonito y pesado

¿que tamaño necesita el computador?

[ ] Para llevar en la maleta todos los días (pequeño)
[ ] Para llevar de vez en cuando en la maleta (mediano)
[ ] No necesito moverlo casi nunca (puede ser de mesa)

¿Presupuesto?

Cuánto dinero está dispuesto a gastar en él

¿Cómo se debería describir un computador portátil?

Describir un computador es mucho más fácil a mi manera de ver si se llenan los siguientes espacios.

Este computador es marca ________ referencia _______ tiene un procesador ______ de __ generación marca intel con una velocidad de reloj de ___ Ghz. Tiene una capacidad de memoria ram de ___ GigaBytes DDR__ expandible a __ ya que (si-no) tiene un espacio disponible para aumentar.

¿ Y tú cómo haces para responderle a tus amigos cuando te preguntan cosas de este tipo ? Escribelo aqui 👇👇👇👇

Google Apps Script support JSDoc and Markdown

Miller Correa — Wed, 19 Jul 2023 18:46:44 +0000

Yes Google Apps Script support Markdown in docs only in your IDE

NOt is supported in the Library Docs Shared

Estructura de carpetas visual Google Drive

Miller Correa — Fri, 09 Jun 2023 13:21:07 +0000

Objetivo

Una de las mejores maneras para entender algun tipo de estructura organizativa, corresponde a los graficos. A dia de hoy Google Drive no cuenta con las herramientas para visualizar graficamente una estructura de carpetas. En sistemas unix existe el comando treeel cual nos permite mostrar de manera gráfica y de forma estructurada la jerarquía de los directorios de nuestro sistema operativo.

Y como logramos tener esta estructura visual en Google Drive?

Avances encontrados

Actualmente se tienen algunas iniciativas las cuales utilizan Google Apps Script para generar un Tree View.

Posible mejora

Se sugiere utilizar la tecnolog[ia de Mermaid para generar graficos en MarkDown a traves de la estructura generada por el Script de Google y obtener una representaci[on visual de la estructura de carpetas.

flowchart LR
    A[Hard edge] -->|Link text| B(Round edge)
    B --> C{Decision}
    C -->|One| D[Result one]
    C -->|Two| E[Result two]

En Notion se veria algo asi

Otra opción más avanzada

Se puede utilizar la API de https://app.diagrams.net/ para crear un grafico que incluya los enlaces a cada uno de las carpetas y podamos navegar de manera m[as rapida.

Si bien diagrams no tiene API si puede usar una herramienta para manipular los diagramas de diagrams.net https://stackoverflow.com/questions/70543817/is-there-draw-io-api-to-manipulate-diagrams

Solución definitiva

Rclone nos proporciona el comando Tree

$ rclone tree remote:path
/
├── file1
├── file2
├── file3
└── subdir
    ├── file4
    └── file5

1 directories, 5 files

Tricks Chrome

Miller Correa — Wed, 10 Feb 2021 21:51:20 +0000

In chrome you can move the current tab to the right with the key combination:

Ctrl + shift + Page Down

And to move to the left you can use:

Ctrl + shift + Page Up

This can improve your productivity by having the tabs you use organized.

Edit web page like a word

Put in developers tools:

document.designMode = 'on'

for off this

document.designMode = 'off'

Shorcuts for Extensions

You can customize the shorcuts to make faster use of the extensions you have installed in your browser. Just go to:

chrome://extensions/shortcuts

Devtools Avanzado

Puede usar la paleta de comandos de las DevTools para acceder mas rapido a las herramientas, primero abra las Devtools y luego presione la combinacion:

Ctrl + shift + P

DEV Community: Miller Correa

DeepSeek Harness: el harness abierto que hace lo que Claude Code no te deja tocar

Qué es DeepSeek Harness

1. Observabilidad: sabes exactamente dónde falló (tool, modelo o usuario)

2. Hardened de verdad: sandbox duro, y aun así no te frena

3. Intervenir en el "look" del Agent (sí, de verdad)

4. Orquestación multiagente de primera clase (no es un afterthought)

5. Self-host: tus datos, tus reglas

6. Skills desatadas del proveedor: un plugin para gobernarlas a todas

La comparación (sin dramatismo)

Por qué es el mejor harness para compañías y startups

El punto

¿Tu agente puede reescribir su propio plan? Ownership determinista con DeepSeek Harness

El contexto: la lista de tareas siempre fue del agente

El GAP: faltaba ownership para el estado de ejecución

La solución: dsh-todo-hardened, ownership para el todo-list

El flujo: proponer, no imponer

Un rastro real, no un diagrama

Por qué esto era imposible antes de DeepSeek Harness

La conexión con agnosticBrain

En resumen

¿La IA está sobrescribiendo tus notas? Tres capas de ownership para proteger tu conocimiento

El contexto: LLM Wiki, la propuesta de Karpathy

El GAP: el conocimiento refinado a mano no estaba protegido

La solución: tres capas de ownership

Cómo congelar una nota: /curate

Cuando el LLM encuentra información nueva: /propose

Cómo se cierra el loop: la aprobación humana

El resto del sistema

En resumen

Conecta Notion y AI en n8n: ¡Adiós API, hola MCP OAuth2!

¿Qué es esto y por qué debería importarme?

¿Por qué esto es mejor que usar el nodo tradicional de Notion?

Tutorial: Conectando Notion vía MCP en n8n

Requisitos previos

Paso 1: El Nodo Mágico

Paso 2: Configuración de Credenciales (El Truco Pro)

Paso 3: El Código (Copy & Paste)

Paso 4: ¡A probar!

Conclusión: El futuro es conversacional

Compartiendo modificaciones de código Sin Internet: La Utilidad del Git Patch

¿Qué es un 'Patch' en Git y Por Qué Deberías Usarlo?

Git Patch: Cómo Compartir Cambios de Código sin Necesidad de Internet ni Repositorios Remotos

1. Creación de un Parche (Patch)

2. Copia y Transferencia del Archivo de Parche

3. ¿Como se usa el parche?

How to use gettext in phoenix?

Pluralización

Ejemplo

Archivos .po en plural

Ventajas de manejar Gettext sin nomenclatura

Plurales, porque complicarse?

Ventaja traducción con los plurales

Desventajas

Mezclar 2 archivos .po

Para test

<%= gettext("The house is very pretty") %>

<%= gettext("The house") %>

<%= gettext("is very pretty") %>

<%= gettext("is very %{house}") %>

<%= gettext("house") %>

<%= gettext("House") %>

Mayusculas y minusculas

Gettext con variables en el string

Usar Gettext dentro de controladores ó liveview

Como hacer una traduccion con un valor que cambia?

¿Es posible generar un gettext que traduzca este texto mediante un unico id?

Ignora archivos solo para ti en Git

¡Ignora archivos solo para ti en Git: domina .git/info/exclude como un pro!

Google Apps Script - Configuración en Codespaces

Como usar Google Apps Script en Codespaces

Configuracion de Clasp en Codespaces

Usar multiples archivos de configuración para las credenciales

habilitar Google Apps Script

Configuracion para correr el comando RUN

💵 ¿Cómo comprar un buen computador?

¿Quién lo va a usar?

¿Para que lo va a usar?

¿ Sistema Operativo?

¿Que programas usan ?

La solución: `dsh-todo-hardened`, ownership para el todo-list

Cómo congelar una nota: `/curate`

Cuando el LLM encuentra información nueva: `/propose`