Quiz Quest
Un cuestionario sobre un tema que de verdad te interese. Aprendes qué pasa entre un clic, una decisión y un puntaje — y escribes las pruebas que demuestran que la calificación está bien.
Listo en la semana 3Un programa privado de 90 días en desarrollo de software: programar, encontrar errores y usar la inteligencia artificial con criterio. Clases individuales con Robert Cushman, tres veces por semana, hasta terminar con una aplicación que tú diseñaste, construiste, probaste y publicaste.
La inteligencia artificial escribe código. El desarrollador es quien tiene que entender el problema, juzgar si el resultado sirve y arreglarlo cuando no. Ese criterio es lo que este programa construye.
El compromiso
Las clases se agendan en horario del centro de México y se dan por Google Meet. Las 12 semanas de enseñanza cubren 84 días; los seis días restantes dan margen para reprogramar y cerrar el proyecto, sin agregar clases.
Lo que vas a construir
Un cuestionario sobre un tema que de verdad te interese. Aprendes qué pasa entre un clic, una decisión y un puntaje — y escribes las pruebas que demuestran que la calificación está bien.
Listo en la semana 3Una aplicación que trae información en vivo de un servicio externo. La lección de fondo es qué mostrar mientras se espera, y qué hacer cuando la respuesta nunca llega.
Listo en la semana 5Una colección privada: juegos, libros, lo que tú coleccionas. Registros que sobreviven a un reinicio y un servidor que verifica quién tiene permiso de leerlos.
Listo en la semana 9Un problema real, para una persona real, que tú eliges. Delimitado, construido, probado, publicado, documentado y mejorado después de ver a alguien usarlo.
Listo en la semana 12El proyecto final puede ser la continuación de uno anterior. Cuatro etapas no significan cuatro aplicaciones distintas empezadas desde cero.
Para qué sirve
La meta es estrecha y se puede comprobar: que entiendas el software que creas lo suficiente para explicarlo, modificarlo, encontrarle la falla y juzgar si de verdad funciona. Los 90 días están ordenados alrededor de esa frase.
Partir un problema en pasos, decir qué debería hacer un fragmento antes de correrlo, y escribir partes pequeñas a mano para que el resto deje de ser una caja negra.
Conectar la pantalla, la lógica, el servicio con el que habla y los datos que guarda — y saber cuál de los cuatro falló.
Dar instrucciones claras y luego comprobar lo que regresa: correr el caso que fallaría, revisarlo contra la documentación oficial y rechazar lo que no puedas explicar.
Historial de versiones, pruebas, documentación y publicación — las prácticas que hacen que el trabajo se pueda revisar.
Quién tiene permiso de ver un registro, qué hace el servidor con datos inválidos, y cómo recuperar la información cuando algo sale mal.
Aplicaciones que se completan, se publican y se usan, en lugar de quedarse a medias en la parte interesante.
El cambio que de verdad estás comprando
La columna de la izquierda no es un fracaso: es donde queda casi cualquiera que aprende por su cuenta con un asistente, y funciona perfecto hasta que algo se rompe y no hay a quién preguntarle. La columna de la derecha es la parte que conserva su valor conforme las herramientas cambian.
Cómo vas a trabajar
Cada clase cierra con diez minutos que resuelves solo, sin IA. En todo el programa son 36 de estos. Veinte no requieren escribir código nuevo — te piden diagnosticar, comprobar, explicar o decidir. Diez te piden escribir algo pequeño: una función, una consulta, una prueba. Seis, reparar una falla concreta.
Esa proporción es intencional, y se parece bastante a cómo es el trabajo en la práctica. Las tareas de abajo tienen nombre fuera del salón de clases, y practicas las seis.
Convertir un "quiero una aplicación que haga esto" en tres condiciones observables que digan si funcionó — y recortar la idea a las tres cosas que de verdad importan.
Intentar romper tu propia aplicación a propósito: campos vacíos, acciones repetidas, identificadores inválidos, un servicio que no responde. Y luego escribir la prueba que evita que vuelva a pasar.
Ver a una persona real usar lo que construiste sin ayudarla, y después separar lo que de verdad la confundió de lo que nada más sugirió.
Trabajar con una lista corta de pendientes, atacar primero el supuesto más riesgoso, y explicar qué le hace un cambio tardío al tiempo y al alcance en lugar de absorberlo en silencio.
Revisar qué cambió — en tu trabajo, en el de un compañero o en el de un agente de IA — y rechazar lo que no puedas explicar, incluidos archivos y dependencias que aparecieron sin que nadie los pidiera.
Publicarlo, saber qué versión está corriendo, recuperar datos después de un error, y dejar por escrito cuánto cuesta y quién lo mantiene.
No son materias extra encima de la programación. Son para lo que sirve la programación, y son la parte del trabajo que no se abarata conforme mejoran las herramientas.
Las 12 semanas
Las tres semanas marcadas son revisiones de avance. Demuestras tu propio trabajo, haces un cambio que no habías visto antes y sin ayuda de IA, y explicas un error que tienes que encontrar. Recibes un resumen por escrito después de cada una.
Dentro de una clase
Los diez minutos del reto individual son la parte que más importa. Los resuelves sin asistencia generativa, en cada clase. Así es como sabemos qué entiendes de verdad, y no qué puedes conseguir que te escriban.
Antes de empezar
Requisitos
No se necesita
Se paga aparte
Si alguien más paga: esa persona recibe información de calendario, pagos y asistencia. Tu trabajo, tus calificaciones y el contenido de nuestras conversaciones se quedan contigo, a menos que tú digas lo contrario.
Cómo vas a saber que está funcionando
En cada una de las tres revisiones te evalúan en nueve cosas concretas: explicar código, escribir una función corta sin IA, encontrar un error, juzgar una sugerencia de IA, seguir cómo se conectan las partes, probar, publicar y recuperar cuando algo se rompe.
Cada una se marca en una escala de cuatro puntos, desde todavía no puedes hasta lo haces solo y sabes explicar por qué. Recibes los resultados y el razonamiento por escrito después de cada revisión.
Al final, dos documentos distintos
El segundo es el que sirve. Alguien puede asistir a todas las clases y aun así necesitar mucho apoyo, y eso se dice con claridad en lugar de entregar un diploma.
Vale la pena decirlo directo
Lo que sí vas a tener es un sistema pequeño que tú construiste, que puedes explicar, que puedes modificar con intención y del que puedes demostrar que funciona — más un informe honesto de dónde estás fuerte y dónde no. Eso es una base real, y es sobre lo que se construye la siguiente etapa.
Quién da la clase
Soy desarrollador full-stack y fundador de CushLabs AI Services, aquí en Guadalajara. Antes de esto trabajé en tecnología empresarial: dirigí proyectos dentro de una manufacturera Fortune 500, y antes hice consultoría de sistemas con Kodak y Corning.
Enseño igual que trabajo: cambios pequeños, probados, explicados y guardados. No vas a ver clases grabadas. Cada sesión es en vivo, uno a uno, y armada alrededor de lo que de verdad te tenga atorado esa semana.
Antes de que nadie se comprometa
Todo lo demás en esta página me toca a mí: la estructura, la enseñanza, la retroalimentación, la evaluación honesta al final. Esta parte no, y prefiero decirlo ahora y no descubrirlo en la semana siete.
El programa solo funciona si haces el trabajo entre clases. De noventa minutos a dos horas después de cada una, tres veces por semana, durante doce semanas. Es más tiempo fuera del salón que dentro, y ahí es donde de verdad ocurre el aprendizaje — las clases son en buena medida donde reparamos lo que salió mal en la práctica.
Yo no puedo hacer la práctica por ti. No puedo poner la concentración, ni las ganas de terminar. Si esa constancia no está, ninguna estructura de mi lado la produce, y seguir de todos modos sería gastar tu dinero y tu tiempo.
La semana uno es interesante porque todo es nuevo. La semana siete es bases de datos, y no lo es. Lo que hagas en esa semana es lo que decide cómo termina esto — y eso es cuestión de compromiso, no de capacidad.
Dicho claro: esto es un trabajo de medio tiempo, o una materia universitaria — de 90 a 108 horas en las doce semanas. Nadie se vuelve desarrollador de software en 90 días, y yo no lo voy a prometer. Lo que esto hace es construir una base que sí vas a poder sostener, y las bases cuestan horas.
De qué está hecha la práctica después de cada clase
Solo una de esas cinco es construir. Las otras cuatro son la razón por la que dos horas de práctica producen algo que dos horas de generar código no — y la de predicción es la que no puedes delegarle a un asistente.
Siguiente paso
La llamada que me gustaría tener no es una evaluación. Sin código, sin preguntas que tengas que contestar bien, sin nada que preparar ni repasar. No te estoy tratando de cachar en un error.
Quiero escuchar qué te gustaría construir, y si estás dispuesto a seguir cuando deje de ser novedad. Eso es lo único que de verdad no puedo juzgar desde un documento.
Si encaja, te digo por dónde te empezaría y qué creo que puedes alcanzar de manera realista en 90 días. Si no es el momento, también te lo digo — antes de que pagues nada.
A 90-day private program in modern software development — coding, debugging, and disciplined use of AI. Taught one-to-one by Robert Cushman, three classes a week, finishing with an application you designed, built, tested and released yourself.
AI can produce code. The developer is the one who has to understand the problem, judge whether the result works, and fix it when it does not. That judgment is what this program builds.
The commitment
Classes run on the America/Mexico_City calendar and are delivered over Google Meet. The 12 teaching weeks cover 84 days; the remaining six give room for rescheduling and final handoff without adding classes.
What you build
An interactive quiz on a subject you actually care about. You learn what happens between a click, a decision and a score — and write the tests that prove the scoring is right.
Completed by week 3An application that pulls live information from an outside service. The real lesson is what to do while waiting, and what to show when the answer never arrives.
Completed by week 5A private collection — games, books, whatever you collect. Records that survive a restart, and a server that checks who is allowed to read them.
Completed by week 9One real problem, for one real person, chosen by you. Scoped, built, tested, deployed, documented, and improved after watching someone use it.
Completed by week 12The final project may extend an earlier one. Four milestones do not mean four unrelated applications started from nothing.
The point of it
The goal is narrow and testable: you should understand the software you create well enough to explain it, change it, troubleshoot it, and judge whether it actually works. Everything in the 90 days is arranged around that sentence.
Break a problem into steps, say what a piece of code should do before running it, and write small parts by hand so the rest stops being a black box.
Connect the screen, the logic, the service it talks to, and the data it stores — and know which one broke.
Give an assistant a proper brief, then test what comes back — run the case that would fail, check it against the official documentation, and refuse anything you cannot explain.
Version history, tests, documentation and deployment — the practices that make work reviewable.
Who is allowed to see a record, what the server does with bad input, and how to get the data back when something goes wrong.
Applications that get completed, released and used, rather than abandoned at the interesting part.
The shift this is really buying
The left column is not a failure — it is where almost everyone lands after teaching themselves with an AI assistant, and it works right up until something breaks and there is no one to ask. The right column is the part that keeps its value as the tools keep changing.
How you will be working
Each class ends with ten minutes you work through alone, without AI. Across the program there are 36 of these. Twenty of them require no new code at all — they ask you to diagnose, verify, explain or decide. Ten ask you to write something small: one function, one query, one test. Six ask you to repair a specific fault.
That ratio is deliberate, and it is roughly what the work looks like in practice. The tasks below have names outside a classroom, and you practise all six.
Turning "I want an app that does this" into three observable conditions that say whether it worked — and cutting the idea down to the three features that matter.
Trying to break your own application on purpose: empty input, duplicate actions, invalid IDs, a service that does not answer. Then writing the test that stops it happening twice.
Watching a real person use what you built without helping them, then separating what genuinely confused them from what they merely suggested.
Working from a small backlog, tackling the riskiest assumption first, and explaining what a late change does to time and scope instead of silently absorbing it.
Checking what actually changed — your own work, a teammate's, or an AI agent's — and refusing anything you cannot explain, including files and dependencies that appeared without being asked for.
Releasing it, knowing which version is running, restoring data after a mistake, and writing down what it costs and who maintains it.
These are not extra subjects layered on top of the coding. They are what the coding is for, and they are the part of the work that does not get cheaper as the tools improve.
The 12 weeks
The three highlighted weeks are progress reviews. You demonstrate your own work, make a change you have not seen before without AI assistance, and talk through a bug you have to find. You receive a written summary after each one.
Inside one class
The ten-minute independent challenge is the part that matters most. You complete it without generative assistance, every class. It is how we find out what you actually understand rather than what you can get produced for you.
Before starting
Required
Not required
Paid separately
If someone else is paying: they receive scheduling, payment and attendance information. Your coursework, scores and the content of our conversations stay private to you unless you say otherwise.
How you will know it is working
At each of the three reviews, you are scored on nine specific things — explaining code, writing a short function without AI, finding a bug, judging an AI suggestion, tracing how the parts connect, testing, releasing, and recovering when something breaks.
Each is marked on a four-point scale, from cannot yet do this to does it independently and can say why. You get the scores and the reasoning in writing after each review.
At the end, two separate documents
The second document is the useful one. Someone can attend every class and still need substantial help, and you should be told that plainly rather than handed a certificate.
Worth saying plainly
What you will have is a small system you built, can explain, can change deliberately, and can prove works — plus an honest account of where you are strong and where you are not. That is a real foundation, and it is what the next stage of learning is built on.
Who teaches it
I am a full-stack developer and the founder of CushLabs AI Services, based in Guadalajara. Before that I spent my career in enterprise IT — leading technology projects inside a Fortune 500 manufacturer, and earlier doing IT consulting work with Kodak and Corning.
I teach this the way I work: small changes, tested, explained, and committed. You will not be watching recorded lectures. Every class is live, one-to-one, and built around whatever you are actually stuck on that week.
Before anyone commits
Everything else on this page is mine to deliver — the structure, the teaching, the feedback, the honest assessment at the end. This part is not, and I would rather say so now than discover it in week seven.
The program only works if you do the work between classes. Ninety minutes to two hours after each one, three times a week, for twelve weeks. That is more time outside the classroom than in it, and it is where the learning actually happens — the classes are largely where we repair whatever went wrong in the practice.
I cannot do the practice for you. I cannot supply the focus, or the wish to finish. If that follow-through is not there, no amount of structure on my side produces it, and pushing through anyway wastes your money and your time.
Week one is interesting because everything is new. Week seven is databases, and it is not. What you do in that week is what decides how this ends — and that comes down to commitment, not ability.
The honest framing is that this is a part-time job, or a real college course — 90 to 108 hours over the twelve weeks. Nobody becomes a software developer in 90 days, and I would not claim it. What this does is build a foundation you actually own, and foundations take the hours.
What the practice after each class is made of
Only one of those five is building. The other four are why two hours of practice produces something two hours of generating code does not — and the prediction drill is the one you cannot hand to an assistant.
Next step
The call I would like is not an assessment. No code, no questions you have to get right, nothing to prepare or revise for. I am not trying to catch you out.
I want to hear what you would actually want to build, and whether you are prepared to keep going once it stops being novel. That is the only thing I genuinely cannot judge from a document.
If it is a fit, I will tell you where I would start you and what I think you can realistically reach in 90 days. If it is not the right time, I will tell you that instead — before you pay anything.