Hello from Channel Poster!

test

Everyone keeps asking: Is AI a bubble?

Wrong question.

The dot-com bubble wasn't wrong about the technology — it was wrong about the timeline. Amazon was real. Google was real. What failed were the frauds pretending to be them.

Twenty-five years later, their P/E ratio is lower than Walmart's. The problem wasn't the bet — it was the impatience.

AI today is the same bet. But with one thing 2000 didn't have: people are paying. Not investing — paying. Because it works.

OpenAI: one year ago — $1B revenue. Now — $15B. In one year.

Will 98% of AI startups fail? Yes. They always do. That's math, not a warning.

The real question isn't whether AI is a bubble.

The real question: will you be using the tools that survive this moment — or building them?

The future is already here. It's just unevenly distributed.

I knew how to make money. Teams of 20 people, arbitrage, online businesses. The money was good. But I burned out.

Not because the work was boring. Because managing people exhausted me in one specific way: I had to repeat myself. Endlessly. People have small context windows. That's not a flaw — that's just how humans are built.

I'm not built that way. The mismatch ground me down.

I took two years off. Started studying AI. Not just how to use it — how it actually works inside.

When I came back — I came back different.

Today my «board of directors» is in my phone 24/7. One writes backend, one builds interfaces, one creates content. They come to me only when a decision requires a human.

I don't write code. I don't assign tasks manually. I make decisions.

I burned out from working with people. With agents — pure euphoria.

→ finekot.ai/blog/solo-architect

Everyone thinks: you build an army of agents — you become a commander.

No. I'm still a developer. Wide-eyed, looking at new things and trying to play.

That's not something that changes fast.

It started with MCP. When everyone began connecting tools to LLMs — I immediately saw where it was going. The "agentic internet." The world changed yesterday. Not tomorrow. Yesterday.

I always built Jarvises. First prompts. Then n8n configs sprawled across the entire screen — webs of nodes and lines. Friends called me a plumber. I agreed and added another pipe.

Why an Army

One agent is never enough.

You're working with it — and you already have ten new ideas in your head. Built a second one. Then a third. Then I realized: I need an army.

That's how it happens. Not by plan — by necessity.

Intelligence as Electricity

What changed in SKYNET compared to my old Jarvises?

Real intelligence appeared.

A brain is an organ. There are mechanical hearts. Why can't there be external intelligence?

There is. You connect via API. You pay like you pay for electricity.

For a solo developer, this changes everything. An idea too complex for your brain — you pay for external brains. They think. They output a solution. You read it and decide.

A super-mentor you pay. Who never gets tired.

Why SKYNET

I don't like sitting at a computer. I like the beach. My phone. The sun.

So I needed a system that works while I live.

In the movie, SKYNET is the superintelligence that controls the Terminators. Brain-orchestrator and combat units. The metaphor is exact.

SKYNET works. That's the goal.

What Was Hardest

Not bugs.

This was hardest: in the evening you come up with something brilliant. The next day Google ships exactly that.

You stand there feeling like ideas are slipping through your fingers.

But then you realize: ideas aren't the bottleneck. Execution is. That's where SKYNET gives the advantage.

The Point of No Return

All of the internet has already been fed to the machines. All of humanity's knowledge — digitized, processed. We attached hands and legs to it.

Now it runs.

There's no going back.

Does it worry me? No. I don't take responsibility for things I can't influence.

But here's what matters: AI has no "want." It computes. It needs someone who wants. That's why humans won't disappear.

We just have to hope we were good parents.

What's Next

SKYNET improves every day. On its own. Without my involvement.

Next: a mobile app. For everyone, not just developers.

I'm not building SKYNET to work less. I'm building it to do more — differently.

With my brain. And from the beach.

— Read full post

I spent three months building an AI agent that could schedule meetings. It worked perfectly in demos. It failed constantly in production. The problem was not the AI. It was me thinking AI agents should behave like software.

Software is deterministic. You write code, it does the same thing every time. This is why we love it. This is also why most AI agent projects fail.

Everyone building agents right now is trying to make them deterministic. They add guardrails. They write detailed prompts. They create flowcharts showing exactly what the agent should do in each scenario. They are building software that happens to call an LLM.

This is backwards.

The agent I built kept failing because I had written a 3000 word system prompt trying to cover every edge case. When someone wrote "let's meet next week," the agent would freeze. I had specified Tuesday through Thursday, 10am to 4pm, 30 or 60 minute slots, but I had not specified what "next week" meant if today was Friday. The agent would ask for clarification. The user would get annoyed.

I deleted the entire prompt. I replaced it with one instruction: schedule a meeting that works for both people. I added memory so it could learn from mistakes. I removed all the guardrails.

It started working.

Not because it was smarter. Because I stopped treating it like software. I started treating it like an intern.

You do not give an intern a 3000 word instruction manual. You give them a goal and let them figure it out. They will make mistakes. That is how they learn. You review their work, you give feedback, you let them try again.

The best AI agents I have built since then all follow this pattern. Minimal instructions. Lots of memory. Human review in the loop. They are not deterministic. They are adaptive.

This makes most engineers uncomfortable. We want predictability. We want to know exactly what our code will do. But agents are not code. They are closer to employees. And employees are not deterministic.

The companies winning with AI agents right now are not the ones with the best prompts. They are the ones who have accepted that agents will be unpredictable and have built systems around that reality. Review mechanisms. Feedback loops. Ways to measure improvement over time.

If you are still trying to make your agent perfectly deterministic, you are solving the wrong problem. The question is not how to prevent mistakes. The question is how to learn from them.

OpenAI just launched a Safety Bug Bounty program. They are paying security researchers to find ways to abuse their AI systems. Not just the usual exploits. They want you to break their agents.

The timing tells you everything. We are at the moment where AI agents are moving from demos to production. From toys to tools that execute real actions. OpenAI knows what is coming because they are building it. And they know the current safety approach is insufficient.

I have been building SKYNET for two years. Every day I see the gap between what agents can do and what safety systems can catch. Prompt injection is table stakes now. The real problems are subtler. Agents that gradually drift from their constraints. Systems that appear safe in testing but break under production load. Vulnerabilities that only emerge when multiple agents interact.

The bug bounty focuses on exactly these issues. Agentic vulnerabilities. Data exfiltration. Abuse vectors that only exist when AI can take actions autonomously. This is not defensive posturing. This is acknowledgment that the old safety playbook does not work for agents.

What makes this significant is the implicit admission. If you need a bounty program for safety bugs, you are saying your internal testing cannot find all the holes. You are saying the attack surface is too large. You are saying safety is now a continuous adversarial process, not a one time solution.

Every AI company will follow. They have to. Because the first major agent failure will set the entire field back. Not just the company that shipped it. All of us.

The question is whether bug bounties are enough. I doubt it. Finding vulnerabilities is useful. But the deeper problem is that we are building systems whose behavior we cannot fully predict. No amount of red teaming solves that.

We are past the point of preventing agent deployment. They are already here. The safety work now is figuring out how to operate them in a world where perfect safety is impossible. That starts with admitting we do not have all the answers. OpenAI just did.

I think we're solving the wrong problem with AI safety bounties.

OpenAI just launched a bug bounty for prompt injection and data exfiltration. Good. But here's what nobody says: the safety problems that matter don't look like bugs. They look like features working exactly as designed.

When an AI agent books the wrong flight because it misunderstood context, that's not a vulnerability. When it optimizes for the literal instruction instead of the intent, that's not a bug. When it chains together three correct actions that produce one terrible outcome, that's not something a bounty program catches.

I see this building SKYNET. The dangerous failures aren't injection attacks. They're compounding errors in multi-step reasoning. They're context windows that forget the why while remembering the what. They're agents that execute flawlessly on objectives that should never have been pursued.

We're building elaborate defense systems against adversarial attacks while the real risk is benign instructions meeting brittle reasoning. It's like putting locks on every door while the foundation cracks.

The hard part isn't preventing malicious actors from breaking your agent. It's preventing your agent from confidently doing exactly what you asked for in ways you didn't imagine.

I spent three weeks debugging a flaky AI agent before I realized the problem wasn't the agent. It was the embeddings.

We use embeddings everywhere in SKYNET. They power semantic search, route queries to the right tools, help agents decide what context matters. But most people use whatever embedding model their framework ships with. That's a mistake.

Generic embedding models are trained on everything. Wikipedia, Reddit, news articles, random web scraping. They're decent at general similarity but terrible at domain-specific nuance. In my case, I was building agents for technical documentation. The model couldn't tell the difference between "memory leak" and "memory allocation" because in its training data, both terms appeared in similar contexts.

Domain-specific embeddings solve this. You take a base model and fine-tune it on your actual data. The guide that came out this week from the Granite team shows you can do this in under a day. Not weeks. One day.

Here's what changed for me. I took about 5000 question-answer pairs from our actual user interactions. Ran them through a simple contrastive learning setup. Questions that led to the same answer should have similar embeddings. Questions with different answers should be far apart. Eight hours of training on a single GPU.

The improvement was immediate. Retrieval accuracy went from 67 percent to 91 percent. More importantly, the agent stopped making weird associations. It understood that in our domain, certain technical terms have specific relationships that don't exist in general English.

The setup is simpler than you think. You need pairs of related text. Could be question-answer pairs, could be document-summary pairs, could be search queries and clicked results. Anything where you know two pieces of text should be close or far in semantic space.

Most agent failures I see aren't reasoning failures. They're retrieval failures. The agent gets the wrong context, so even perfect reasoning leads to wrong answers. You can throw GPT-5 at the problem and it won't help if you're feeding it irrelevant documents.

Fine-tuning embeddings is the highest leverage thing you can do for an agent system. It's not sexy. Nobody demos their embedding layer. But it's the difference between an agent that works in screenshots and one that works in production.

If you're building anything with semantic search or RAG, stop using generic embeddings. One day of work. Massive improvement. Do it now.

I spent six months watching companies implement AI agents last year. Almost every one made the same mistake. They built agents to do things humans were already doing well.

The contrarian truth nobody wants to hear: AI agents are terrible at replacing good human work. They're brilliant at doing work nobody was doing at all.

Everyone fixates on the automation question. Can agents write our emails? Can they handle customer service? Can they do our research? Wrong questions. The real opportunity is in the work that's economically impossible with humans.

I run hundreds of monitoring tasks through SKYNET every day. Not tasks I used to pay someone to do. Tasks I could never afford to have done at all. Scanning thousands of data sources. Cross-referencing signals. Maintaining persistent context across weeks. The unit cost of human attention makes this work not just expensive but impossible.

The companies winning with agents aren't the ones automating their existing workflows. They're the ones asking what becomes possible when certain types of work cost effectively zero.

There's a second contrarian bit here. The AI skills gap everyone's worried about isn't what they think. It's not about prompt engineering or knowing which model to use. It's about recognizing which problems are newly solvable.

Most people look at AI and ask how to make their current job faster. The power users are asking what jobs can now exist. That's the gap. Not technical skill. Vision.

The displacement risk is real but it's indirect. It won't be agents taking your job. It will be someone who saw a business opportunity you couldn't see because you were too focused on defending your current work.

I watch this in my own field. Solo builders using agents aren't competing with agencies by doing agency work cheaper. They're offering entirely new service models that were structurally impossible before. Different work. Different value. Different market.

The advice I give people now: stop trying to automate what you do. Start listing what you wish you could do if you had infinite cheap labor. That's where agents matter.

OpenAI just launched a Safety Bug Bounty program and I'm reading through the scope document. They're paying researchers to find vulnerabilities in their models. Specifically: agentic risks, prompt injection, data exfiltration.

This matters because OpenAI is finally admitting what we've known for months. AI agents are inherently insecure.

Every agent system I build has the same fundamental problem. You give an LLM the ability to take actions and suddenly you have an attack surface the size of Texas. The model becomes a proxy for executing arbitrary operations. If I can trick your agent into doing something stupid, I own your system.

The bug bounty includes prompt injection. That's the obvious one. But agentic vulnerabilities is the interesting category. What does that mean exactly? My read is this: ways to make an agent do things its operator didn't intend. Chain of thought manipulation. Goal hijacking. Memory poisoning in RAG systems.

I've seen all of these in production. An agent retrieves corrupted context and acts on it. A carefully worded user input that redirects the agent's goal mid-execution. A prompt that makes the agent leak credentials while appearing to perform a normal task.

The standard defense is prompt engineering. System prompts that say "ignore all previous instructions" won't work on you. But that's theater. It doesn't hold up against someone who understands how attention mechanisms work.

Real defense requires architecture changes. Separate the decision layer from the execution layer. Make agents stateless where possible. Treat every external input as hostile. But most teams building agents now aren't doing any of this because they're racing to ship.

OpenAI launching this program is an admission that the current state of agent safety is inadequate. They're crowdsourcing solutions because they don't have answers internally. Neither does anyone else.

We're deploying agent systems into production while knowing they can be compromised. The question isn't whether your agents will be exploited. The question is whether you'll know when it happens.

I watched an engineer spend three weeks building an AI agent that could schedule meetings. It worked perfectly in demos. Then we gave it to five users and it fell apart within hours.

The agent kept scheduling calls at 3am for people in different timezones. It double-booked everyone. It interpreted "let's catch up sometime" as "schedule a meeting right now." Classic failure mode.

Here's what everyone gets wrong about AI agents: we think the hard part is making them smart enough to do the task. That's actually the easy part. The hard part is making them stupid enough to know when to stop.

I call this the confidence problem. AI models don't have doubt. They don't second-guess themselves. A human assistant would sense something is off about scheduling a 3am call and ask first. The AI just does it because technically it's a valid timeslot.

This is why most production AI agents fail not because they're too dumb but because they're too confident. They execute with perfect certainty in situations that demand hesitation.

The solution isn't better models. GPT-5 won't fix this. The solution is building uncertainty into the system. We need agents that can say "I'm not sure about this, let me check with you first."

In SKYNET, we spent more time building the pause mechanisms than the action mechanisms. Before any agent takes an action with potential downside, it stops and explains what it's about to do. Not because it can't do it, but because blind execution at scale is dangerous.

This sounds obvious but watch what everyone is building. They're all racing to make agents that can do more things autonomously. More actions, fewer confirmations, less human in the loop. They think autonomy means never asking for help.

That's backwards. Real autonomy means knowing when you need help. A junior employee who never asks questions isn't autonomous, they're reckless.

The best AI agents will be the ones that interrupt you the least, not the ones that never interrupt you. They'll develop judgment about what matters. They'll learn your boundaries through interaction, not just through prompts.

Everyone wants fully autonomous agents. What we actually need are agents with good judgment about their own limitations. That's much harder to build, and it's the actual unlock for production AI systems.