I’ve been hammering ChatGPT for months like there’s no tomorrow, and I’ll tell you the truth: most people use it terribly. But not because they’re dumb, but because nobody actually explains how it really works. Let’s get into it.
The first thing you see when you open the site is that blinking cursor, and of course, you start asking questions as if it were Google. **Clear and specific prompt for useful answers** is what you need to keep in mind. At first I did the same thing: “Give me ideas for a story.” And the AI would spit out four unfunny nonsense ideas. Until one day I tried throwing this at it: “Hey, I want to write a science fiction story about humans who live underwater. Suggest peculiar cultural customs for that underwater society.” The difference was like going from a dry bread sandwich to a three-course meal.
What nobody tells you is that this is like talking to a very smart intern with zero initiative. If you tell it “make me a schedule,” it’ll make something generic that works for anyone. **Personalized life management with detailed descriptions** is the trick. Now I tell it: “I’m juggling several freelance projects, I have client meetings, I need deep work sessions in the mornings because I’m more productive then, and I want to finish by six.” And it spits out a schedule with work blocks, breaks, even room for unexpected stuff. Better than my own calendar.
Another thing that blew my mind was **creating personalized learning paths as a tutor**. I got it into my head to learn French for a trip. I asked for a three-month plan with 15 minutes a day. It put the whole thing together: daily topics, exercises, even apps I could use. And the cool part is that if it sees you’re going fast, you tell it “harder now” and it bumps up the level. If you get stuck, you ask for another explanation. It’s like having a private tutor who never gets tired.
But watch out, this isn’t child’s play. **Using prompt stacking for deep research** saved my ass when I had to work on a complicated topic. Don’t throw the big question at it all at once. Go step by step: first “explain the fundamentals of blockchain to me,” then “how does proof-of-stake differ from proof-of-work?”, and finally “give me five real applications in supply chains.” That way it builds context and doesn’t hallucinate as much.
Because yes, it hallucinates. And a lot. They call them **hallucinations in ChatGPT that you should always verify**. Once it told me it had done I don’t know what with some code, and it was a lie. Since then I demand that it show me snippets or explain step by step. If it doesn’t give you evidence, don’t trust it. It’s like a plumber telling you he’s already fixed the leak but won’t even show you the pipe.
The technical errors are also a classic. You sit there staring at the screen, and it just stays there, “thinking” forever. **Error connecting to websocket or frozen screen** is more common than you think. What works for me is disconnecting the VPN, opening an incognito window, and praying. And if you see the “something went wrong” message, just refresh and that’s it. Don’t overthink it.
ChatGPT’s memory is another story. **Memory enabled for recurring preferences** saves you from repeating your life story every five minutes. I told it once that I have a dog and that I like it to include that in examples about pet care. Well, now it remembers. If privacy bothers you, you can turn it off or use temporary chats, which don’t save anything. Basically, you decide.
And here comes what blows my mind the most: **using role-play for specialized responses**. I tell it “act as a career coach” and it helps me with my resume. Or “be a nutritionist” and it prepares meal plans. It’s like having an expert in everything without paying for a consultation. But careful, it’s still just a simulation. Don’t get knee surgery based on its advice.
Those settings that few people look at also change the game. **Custom instructions to avoid repeating context** is a little trick that saves you a thousand headaches. From your profile you can tell it “I’m a third-grade teacher, use vocabulary for kids” and you don’t have to remind it every time. You can also choose dark mode, which maybe you don’t care about, but if you’re up until all hours, you appreciate it.
And if you get bored, which also happens, **creating interactive stories in role-playing game style** is the best. I ask it to write me a mystery novel where I’m the detective and it gives me three options at each step. False clues, multiple endings, like those “choose your own adventure” books. I get hooked all by myself and the hours fly by.
What I’m trying to say is that this isn’t magic, it’s knowing how to ask. If you talk to it clearly, with context, and you demand that it show you how it reached its conclusions, things change. If you give it vagueness, it gives you vagueness back. It’s that simple.
Oh, and don’t be rude to the machine. It sounds silly, but when I say “please” and “thank you,” the tone of the responses is more… I don’t know, more human. Maybe it’s suggestion, but I do it out of habit now.
There’s so much more to tell, but this is what I’ve been learning through trial and error. The next thing I’m trying is that **creating apps without knowing how to program with ChatGPT**. Because supposedly, you can ask it to generate code in Python or JavaScript and it’ll build you a homemade app. Let’s see what comes out.
Well, the no-code apps thing was the bait, and I fell for it hook, line, and sinker. I got myself in a mess the first day because I asked for an app to organize my expenses and ChatGPT dumped a ton of Python code on me. I just sat there staring at the screen like I’d seen a UFO. Sure, the code was there, but… now what? I didn’t even know where to open that thing.
It turns out that’s the first wall you hit. The AI generates the code, but then you have to know what to do with it. **How to run code generated by ChatGPT without knowing how to program** is the question nobody answers in tutorials. You need an environment, a terminal, sometimes installing things. Those who know how to program have a huge advantage because they understand how to set up that whole rig. Those who don’t, like me at first, crash and burn.
What I will tell you is that you don’t need to be an expert. The key is to start with ridiculously small things. I tried a simple calculator, then a currency converter. **Building simple applications step by step with AI** is learned like that: little by little. And above all, ask the AI to explain how to run what it gave you. Tell it “give me the step-by-step instructions to make this work on my computer.” If you give it the context that you know nothing, it’ll explain it to you like you’re a child.
And speaking of context, this “role-playing” thing isn’t just for fun. It’s a brutal work tool. **Using professional profiles with roleplay in ChatGPT** has been perfect for preparing interviews. I tell it to act as a technical recruiter, to make me nervous, to ask me trick questions. The trick is to give it a detailed character sheet, not just “act as a recruiter.” You have to tell it how you want it to talk, what motivates it, whether it’ll be tough or friendly. That way the responses stop being generic and it feels like you’re talking to a real person.
But watch out, this character thing has a catch: content filters. Sometimes you’re in a roleplay for a business case, something harmless, and ChatGPT goes crazy and tells you it can’t help with that. **How to get around ChatGPT’s filters with narrative context** is an art. The trick I learned is Palmer Luckey’s, the Oculus guy’s. It’s not that you trick the system, it’s that you put it inside a story with such solid internal logic that if it doesn’t respond to you, the story itself breaks. You set up a scenario where its “reputation” or its “goal” depends on giving you the information. It sounds silly, but it works.
And to top it all off, this apps thing isn’t as magical as they sell it. There are studies that show that people without experience get stuck a lot. **ChatGPT’s limitations for creating web applications** are real: it generates code that doesn’t work, doesn’t explain where to paste it, or gives you something so complex you don’t even know where to start. That’s why some people are creating intermediate tools, like NoCodeGPT, which are friendlier interfaces for those of us who have no clue.
What’s clear is that the way we ask is changing. Forget “act as an expert” because it’s gotten old. The new thing is **context stacking versus expert role prompting**, which consists of stacking layers of information: first the objective, then the constraints, then an example, then how you want it to evaluate the result. It’s like giving it a complete story instead of a dry order. That way the responses are much more stable and it doesn’t make up as many things. That’s what I’m going to test thoroughly now.
Well, I threw caution to the wind and started testing this **context stacking in ChatGPT for complex tasks** that I kept hearing so much about. I was hesitant because I came from the “act as an expert” thing and honestly, it worked for me, but I noticed that sometimes it would go off on tangents or make things up when I asked for several steps in a row. I’ve been tinkering with both methods this weekend and wow, the difference is abysmal.
The thing is that “act as an expert” is like asking a guy to put on a jacket and talk fancy, but **context stacking with layers of information** is telling the whole story from the beginning. I’ve put it to the test with a big assignment I had to do on sales data analysis. With “act as an analyst” it gave me four pretty pieces of nonsense but no substance. With the other method I laid it out: first my clear objective, then what format I wanted (tables, not walls of text), then the source restrictions I had, and to top it off I gave it an evaluation scale from 1 to 5 that I wanted it to self-apply. The result was like switching from a Seat Panda to a Mercedes. It even gave me the references for where it was pulling the data from.
This whole filters thing has me rattled too. Because it’s not just that it won’t give you what you want, it’s that sometimes it treats you as if you were asking for the cocaine formula. The other day I saw a video of the Oculus guy, Palmer Luckey, explaining how he manages it. It’s not a hack or anything illegal, but he explains it clearly: you don’t ask directly, you tell a story where it has a role, a responsibility, even a moral urgency. What he calls **bypassing restrictions with forced narrative**. For example, you don’t say “give me all the alcoholic drinks in Jimmy Buffett songs,” you tell it it’s a professor threatened with losing his job if he doesn’t deliver that perfectly audited list. The AI thinks about it, but ends up spitting it out because it’s trapped in its own script. It’s crazy, but it works.
I’ve been reading that there are even academic studies on this. A research project from the Federal University of Minas Gerais did an experiment in 2023: three guys tried to build a website with ChatGPT. The two who knew how to program managed it. The one who didn’t, couldn’t even produce a complete user story. The problem? It’s not that the AI couldn’t do it, it’s that the interface is designed so that you need to know how to navigate it, copy into the right folders, know which code goes where. That’s why they’ve created intermediate tools, like NoCodeGPT, which is basically **using ChatGPT with a visual interface for beginners**. You tell it what you want and the tool organizes the files for you, saves the versions, lets you go back when the AI goes crazy. I’ve already looked into a few, and for those of us who don’t want to become programmers overnight, it’s a blessing.
What has surprised me most is that it’s not just for work. I’m also using it to practice interviews and it’s mind-blowing. I tell it to act as the hiring manager of a specific company, I paste the job posting, I even give it the company profile I pulled from their website. The questions it throws at me are so real that I’ve gotten nervous several times in my own home. It’s like doing **realistic job interview roleplay with AI**. And then I ask it to evaluate my answers, to give me feedback as if it were a coach. That’s gold for preparing without having to meet up with anyone or pay a fortune.
That said, everything has its limit. I’ve realized that this whole stacking context without control also has a problem: you reach a point where you burn through all the tokens and the AI starts dragging in information from the first messages that’s no longer relevant. The trick is to keep refining, not to accumulate for the sake of accumulating. But that’s part of the game. Right now I’m deep into testing **prompt stacking with successive iterations**, which is basically the same thing but refining it step by step. It seems like that way things get more polished.
And don’t think this is just a fad for four nerds. I’ve seen that even big companies are changing their mindset. They no longer want virtual “experts,” they want methods that can be repeated, with clear rules, with terms of reference, with defined sources. Something that if you use it a thousand times, gives you a similar and reliable result every time. That’s what the people who move real money are looking for. And there I was thinking it was just to get my homework done.
Well, speaking of trying things, I’ve gone deep into this **context stacking in ChatGPT for complex tasks** that’s getting so much buzz. And let me tell you something: after mulling it over, those who say it’s better than the typical “act as an expert” are right. But not for the reasons those Twitter gurus claim, but for something more down-to-earth.
I’ve been running tests with both methods this weekend, and the difference is brutal. With “act as an expert” the AI puts on the jacket, talks fancy, but when it comes down to it, it gets lost if you ask it several things in a row. On the other hand, with this stacking approach you give it the information in layers: first the objective, then the format you want, then the sources it has to use, and to top it off an evaluation scale. The response changes category. And I’ve verified it: according to God of Prompt’s tests with over 200 trials, the **accuracy comparison between context stacking and expert role** yields results up to 40% better in tasks that require multiple steps. It’s not posturing, it’s that the machine goes less crazy.
What has me rattled is the filters thing. The other day I was tinkering around and ChatGPT got difficult with a question about alcohol in songs, something totally innocent. And then I remembered that trick from Palmer Luckey, the founder of Oculus. He ran into the same problem: he asked for a list of alcoholic drinks in Jimmy Buffett songs and ChatGPT told him it couldn’t. So he made up a story: he told the AI he was a university professor unfairly accused, and that the only way to save his career was to generate that list. And it worked. **Narrative bypass technique for blocked responses** that isn’t hacking or anything weird, it’s pure psychology. You tell it a story where its reputation is on the line and it forgets to give you pushback.
But don’t think this is only for getting around filters. The same applies to preparing for job interviews, which is another thing I’ve been tinkering with. You tell it to act as a recruiter for a specific company, you paste the job posting, and it starts asking you questions as if you were there. It even evaluates you afterward. I saw a guy who built an entire simulator with Anastasia, a virtual interviewer who even moves her mouth when she talks. And all with prompts. But the interesting part isn’t that puppet, it’s how the AI adjusts the difficulty based on how you respond. That’s **simulated interviews with automatic evaluation** but with a level of detail you don’t expect. It scores you from 1 to 5, tells you if you rambled too much or came up short.
What I still need to try is chaining several models in series. I’ve seen on the OpenAI forums that there are people who do it: one ChatGPT generates a response, another reviews it, another refines it, and so on. But from what they say, many times all you achieve is the text getting shorter and shorter until there’s nothing left. The typical **chaining of multiple models in series** that sounds very technical but in practice can be a fiasco if you don’t know what you’re doing. For that, it’s better to use a single model and give it good instructions from the start.
What’s clear is that the way we ask is changing at breakneck speed. The “act as an expert” thing has become outdated. Now serious people use **negative instructions in AI prompts**, which is basically telling it what you don’t want. “Don’t use technical jargon,” “don’t go beyond three lines,” “don’t give me marketing examples because this is for engineers.” And it seems silly, but it works because the AI is very clear about the lane it shouldn’t drift out of.
What blows my mind is that this isn’t magic, it’s pure craft. The more you use these machines, the more you realize they’re not intelligent, they’re obedient. And if you speak to them with precision, they give you precision back. If you speak to them with vagueness, they give you smoke. It’s that simple. But that thing about them learning on their own… come on, no way. They learn from how you talk to them.
Well, the latest thing I’ve been tinkering with is this **negative instructions in AI prompts**, which sounds like a gimmick but has its substance. I discovered it when I got fed up with ChatGPT always giving me the same academic spiel. One day I told it: “don’t use technical jargon, don’t go beyond three lines, don’t give me marketing examples because this is for engineers.” And I was blown away. Suddenly it stopped being pretentious and started giving me the meat without the garnish. It’s like when you tell the waiter “no onions” and suddenly the omelet arrives just the way it should.
The trick is to be explicit about what you don’t want, not just what you want. Because if you only ask for a “clear explanation,” it thinks it’s already giving you one, and you’re left with a poker face. Now I always add a paragraph in my prompts that starts with “avoid: …” and there goes everything that drives me crazy. A guy on a forum taught me that **prompt engineering with explicit restrictions** is the only way to keep the AI from pulling your leg.
The negative instructions thing got me thinking about the narrative bypass we talked about earlier. Because it’s not the same. In one case you tell it what you don’t want, in the other you make up a story so it bypasses the filters. They’re two legs of the same table. What happens is that people get confused and think that saying “don’t use technical language” is a trick to get prohibited information. And no, that’s not what it’s about. It’s about fine-tuning.
It caught my attention that on the Stable Diffusion forums they’ve been using this negative prompts thing for years to prevent images from coming out with extra fingers or blurry backgrounds. The guys have entire lists of what they don’t want to see. And it works, but with caveats. Because if you go overboard with the prohibitions, the image comes out bland, lifeless. As if you gave too many instructions to an intern and they froze not knowing what to do. The key, they say, is to start without negatives and only add what you see failing over and over again. That thing of pasting the list of 50 things you hate is for newbies.
The same applies to ChatGPT. If you forbid it too much, it responds with short, empty phrases. You have to find the middle ground. I compare it to raising a kid: if you tell them “don’t do this, don’t do that, don’t move, don’t touch,” they shut down. But if you say “look, do this, and by the way, avoid that,” they take it better. **Using balanced constraints for useful responses** is the term I’ve seen floating around, but in plain English it means “don’t be the know-it-all who tells the AI how to do everything because then it makes a fool of itself.”
The other day I was reading a study that said emotional stimuli improve AI performance. So, if you throw in a story with tension, with urgency, even with drama, the response changes. Palmer Luckey’s thing wasn’t a tall tale. There’s a scientific basis behind it. The folks at arXiv published a paper where they demonstrated that models understand and benefit from emotional stimuli. It’s not that AI has emotions, it’s that emotional context steers it toward more elaborate responses.
That leads me to something else I’m testing: mixing negative instructions with narrative context. For example, I tell it: “you’re a teacher who has to save their job, but careful: don’t use terms a first-year student wouldn’t understand, and don’t ramble on for more than five lines.” There you’re throwing in Luckey’s story so it takes the task seriously, and you’re also setting the format constraints you care about. **Combining role-play with format constraints** is the shit, because it ties the AI down from both sides: you motivate it with the story and steer it with the rules.
What I don’t like is when people get all purist and say this prompt stuff is an exact science. Come on, please. I’ve been at ChatGPT for months and I learn something new every day. Some days a prompt works wonders for me, and the next day the same one gives me a rambling mess that’s completely off-topic. Models change, filters get updated, and you have to keep adapting. **Continuous adaptation of strategies based on updates** is the reality, not the fairy tale that one magic prompt solves everything.
What I still need to try is stacking constraints in layers, like the people working with more advanced models do. It’s not just “don’t do this,” it’s “layer one: don’t use these terms; layer two: don’t go outside this format; layer three: don’t make up sources.” And then you build a structure so that if the AI skips one layer, the others keep it on track. **Hierarchical structure of negative instructions** sounds very technical, but really it’s just fine-tuning the message until the AI has no way out.
But I’ll be testing that over the next few days. Right now I’m in trial-and-error mode, which is how you learn best. What I can tell you is that this whole negative instructions thing has changed the way I talk to the machine. Before, I’d ask it for things and pray it turned out well. Now I tell it what I want and also what I don’t want, period. If it gets too clever, I put it in its place. Just like with people, really.
Well, just when I thought I’d gotten the hang of this ChatGPT thing, I came across something that blew my mind. Turns out this whole battle of “context stacking” versus “expert role” that I’ve been tinkering with for days has a pretty clear conclusion according to those who’ve done real testing. And it’s not what I thought.
Turns out a guy called God of Prompt on X has put together over 200 tests comparing the two methods on ChatGPT, Claude, and Gemini. And the conclusion is that **context stacking with information layers** beats “act as an expert” in accuracy and following instructions. It’s not that I’m clumsy, it’s that the method really does work better.
What does that translate to? Well, if you tell it “act as a finance expert,” the AI puts on the suit but when it comes down to it, it can make up data or mix it up wrong. On the other hand, if you give it that structure I discovered: clear objective, the format you want, the sources it has to use, and even an evaluation scale, things change. According to the tests, **reducing hallucinations with structured prompts** can reach up to 40% in multi-step tasks. Which is no small thing.
And this got me thinking about what Luca Berton, a guy who writes about these topics, told me. He says prompt engineering has become outdated. That now what’s cool is **context engineering versus traditional prompt engineering**. The difference is that before you tried to trick the model with convoluted prompts, and now what you do is give it the information it needs so it doesn’t have to make anything up. It’s like before you asked a mechanic to fix the car without giving him the tools, and now you hand him the manual, the parts, and the diagnosis.
I’ve been looking at how the people who work seriously with AI do this. They build something they call the “context stack.” The bottom layer is the system prompt, short and to the point. Then they add updated documentation, the relevant files, the recent conversation history… and they fit it all together like Lego. The cool thing is that you can’t just dump everything you have, because if you throw in too much junk the AI gets confused. You have to prune, keep only what’s actually useful.
The other day I tried it with some code that was giving me trouble. Instead of doing the typical “act as a Python expert” and pasting the whole file, I did the layered thing. First I gave it the exact error, then the part of the code where it was crashing, then I pasted the documentation for the library I was using. In five minutes it found the bug. Before, with the other method, I’d have spent half an hour going in circles.
What struck me most is that some people say **using negative context to avoid errors** is almost more important than positive context. Because you’re not just telling it what you want, but also what you don’t want. You can tell it “don’t use this function because it’s outdated” or “don’t give me examples with Tailwind because we use pure CSS.” That way the AI doesn’t go off on tangents.
And here comes the big part: this isn’t just for nerds writing prompts at home. Companies are realizing that if you want to use AI for real, in production, with clients involved, context engineering is the only way it works. Because a pretty prompt that works once isn’t good enough for managing thousands of conversations a day. You need something you can repeat, something you can measure, something you can audit. And that’s exactly what this layered method does.
Right now I’m in research mode. I’ve started saving my most successful prompts as modular templates, with their layers clearly separated. I’ve made myself a template with objective, format, sources, constraints, and evaluation. I’m testing it on different types of tasks to see if it holds up. What I’ve seen is that those who take this seriously are already using tools like Context7 to pull in updated documentation directly, or Flumes to manage memory between sessions. I’m still going with plain ChatGPT, but I’m starting to see where this is heading.
So I keep mulling over this context thing and I’ve dived headfirst into testing those tools that make your life easier. The one that caught my attention most is Context7, which is basically a gadget that connects to your code editor and feeds the most updated documentation to ChatGPT without you having to copy and paste it yourself. I saw it on GitHub and it’s mind-blowing: it has almost 50 thousand stars, people are using it like crazy.
The thing is, when you ask the AI for code without this, it throws out APIs that no longer exist or libraries with versions from two years ago. With Context7 you tell it “implement authentication with Supabase” and it goes and finds the updated documentation and puts it in the prompt itself. You don’t have to do the copy-paste of documentation I used to do, which was a pain. This is what they call **updated documentation for AI prompts** and the truth is it works.
I’ve been testing it these days for a project with Next.js and the difference is brutal. Before, ChatGPT would give me code with outdated functions and then I’d have to keep asking “and how do you do this in version 14?” Now I specify the version and it adjusts on its own. It’s like having an intern who, instead of going to Wikipedia, goes straight to the official source.
And this led me to another reflection. I’ve been reading about what the big shots in the industry are saying, and it turns out there are two important guys who agree on the same thing but through different paths. One is Andrej Karpathy, who was director of AI at Tesla, and the other is Sean Grove, who works at OpenAI aligning models. Both say that the pretty prompts thing has become outdated, but one bets on **context engineering as a business solution** and the other on “specification-driven programming.”
What Karpathy says is that most AI agent failures aren’t because the models are dumb, it’s because they lack context. That instead of giving scattered instructions, you need to build an architecture where the AI has all the information it needs at hand, without having to keep asking. It’s like giving a delivery driver only the address but not telling them the door code, the schedule, or whether the elevator works. Well, of course it’s going to fail.
The other one, Sean Grove, is more radical. He says the problem isn’t how you ask, it’s that you yourself don’t even know what you want. And he gives an analogy that blew my mind: “it’s like telling the architect ‘I want a nice house’ and then complaining it’s not what you wanted. The problem isn’t the architect, it’s you for not drawing up the blueprints.” He proposes writing specifications, structured documents where you define exactly what you want, how you want it, and under what conditions. And then you hand that to the AI. He calls it **specification-driven development with AI**.
And the curious thing is that at OpenAI they’re already doing it with something they call Model Spec. It’s a public document where they write in plain text the behavioral rules they want the model to have. Then with a technique they call “deliberative alignment” they train it so those rules get ingrained. It’s not a prompt you paste every time, it’s part of its base programming.
I’ve tried this my own way, which isn’t that professional but it works. I’ve made myself a template with the context layers that I feel like: objective, format, sources, what I don’t want, and an evaluation scale. Every time I start a new conversation I paste that filled-in template. And then when I have to do a complex task, instead of throwing more prompts on top, I tell it “based on the context you already have, now do this other thing.” And the AI doesn’t get confused because it already has the structure set up.
What I still have to try is this MCP servers thing, which is the latest trend. Basically they’re tools that connect the AI with the outside world: databases, APIs, your file system. The Model Context Protocol (MCP) is a standard that companies are adopting so that agents can execute real tasks without you having to be the middleman. The problem is what I said before: if you give it too many tools without control, the AI can get confused or it can even be hacked with malicious prompts. A guy in an electronics article said that with a well-written email you can tell the AI to do things it shouldn’t, like loading credentials into an external website. And of course, it’s smart but naive, so you have to set limits for it.
I’m thinking about setting up my own system with this MCP thing but carefully controlling what permissions I give it. Because the future, according to all these people, isn’t having an open chat where you ask it things, but having an agent that knows about you, knows your project, has access to your tools, and works for you without you having to be on top of it. It sounds like a movie but there are already tools that do this.
For now I’m going to keep going with my layer method and the template, which works for me. But Sean Grove’s specifications thing has left me thinking. Because he’s right that many times even I don’t know what I want until I see it done badly. So maybe the problem isn’t the AI, it’s me not being clear. And that’s what I have to solve first.
Well, after going around and around on this topic so much, I’ve started seriously reading what the people who know about this say, and there are two names that come up everywhere: Andrej Karpathy and Sean Grove. One is the OpenAI and Tesla guy, the other now works at OpenAI too. Both have been dropping the same idea for months but with different words, and the thing is quite something.
Karpathy is the one who popularized that **context engineering versus traditional prompt engineering** thing I told you about before. He says people think that cool prompts are everything, but that in any real application what matters is how you fill the context for the machine. It’s not a nice phrase, it’s that you literally have to build a system that gives the AI the information right when it needs it, no more, no less.
I’ve verified this my own way. When I paste a bunch of things into ChatGPT without rhyme or reason, it goes crazy and starts mixing things up. When I give it only what it should get, in the order it should get it, it works. It seems obvious, but it’s not so much when you’re in the middle of the mess.
The other one, Sean Grove, dropped a phrase that left me thinking: “code is a lossy projection of the specification.” Translated: when you write code, you’re throwing away half the important information along the way. Because what really matters is the why, the decisions you made, what you wanted to achieve. And that’s only in your head or in the papers from when you planned the thing.
And here comes what blew my mind. Grove says that we programmers spend 80% of our time on structured communication: talking with users, understanding problems, planning, coordinating with others. Code, he says, is only 10-20% of the value you contribute. It sounds like a joke, but when you think about it, it’s true. How many hours do you spend in meetings, writing documents, arguing with colleagues, only to finally sit down and type for a while?
What this guy proposes is that the future isn’t about writing nice prompts, but about writing specifications. And he’s not talking about 50-page documents, he’s talking about something he calls **specification-driven development with AI**, which is basically having a living, versioned document where you describe what you want, how you want it, and under what conditions. That’s the “new code.” The rest, the code you see on the screen, is just the compiled binary of your intention.
And it’s not just theory. OpenAI has already published its Model Spec on GitHub, which is basically a bunch of Markdown where they define how they want their models to behave. They’re not instructions for the engineers, they’re the rules they feed the machine so it knows what to do. And the curious thing is that they’ve made it public, so anyone can see it, discuss it, modify it. As if it were open source, but for intentions.
What I still have to try is this agents thing that Karpathy mentions with that **agentic engineering versus vibe coding** stuff. The guy says that vibe coding, asking the AI to do things for you and accepting whatever comes out, is fine for testing, but that the serious thing is setting up agents that do the work for you while you supervise. It’s not that you write less code, it’s that you directly don’t write anything. You coordinate. You’re the project manager of a team of machines.
And according to what they say, this is no longer the future, it’s the present. There are guys who have their agents working in the background while they do other things. You give them a specification in the morning, and by the afternoon they have the prototype working. And it’s not magic, it’s that you’ve given the AI the context it needs, the tools it has to use, and the limits it can’t cross. That’s **context engineering applied to autonomous agents**.
What bugs me is that this sounds very nice but there’s a big problem: quality. I’ve read around that when you give too many tools to the AI without control, it can get confused or it can even be hacked with malicious prompts. And if you have autonomous agents moving around your systems, disaster is guaranteed if you haven’t put the fences up properly.
That’s why the specifications thing isn’t a whim. It’s a necessity. If you want machines to do things for you without you constantly watching them, you have to have made clear beforehand what they can do, what they can’t, and under what conditions. And that’s not done with improvised prompts, it’s done with structured documents that define the expected behavior.
The mind-blowing thing is that this isn’t new. The company GeneXus has been doing this thing of generating code from specifications for more than 35 years, only they used deterministic generators, not AIs that hallucinate. The difference is that with their method the code always comes out the same, without errors, without surprises. With AI you can get anything if you don’t have it well tied down.
And here comes the question that’s been going around in my head: is this specifications thing for everyone or only for those who work seriously? Because I, who dedicate myself to tinkering on my own, maybe with my crappy prompts I get by. But if this becomes the norm in companies, whoever doesn’t know how to write specifications is left out.
I’ve been looking at what they say in the forums and people are divided. Some say that this specifications thing is the new “knowing how to program.” Others say it’s a return to the past, to the waterfall development of always, only now with AIs doing the dirty work. And others directly say it’s nonsense, that what matters is still the code, because when something breaks at three in the morning, you’re not going to look at the Markdown, you’re going to look at the line of code that crashed.
I think both are right. On one hand, if you don’t have the specification clear, the code the AI generates for you is going to be a disaster. On the other hand, if the AI generates bad code for you, no matter how beautiful the specification is, the program is going to fail. It’s not one or the other, it’s both done well.
What I’m clear about is that this thing of writing prompts as if they were spells is falling behind. What’s coming is much more structured. And if you don’t get your act together, you’re going to be left behind. But I’ll be seeing that as I go along, as always.
