Building free investtracker | One dashboard for your global net worth & investments | No more investment Excels. Just data. 📉
Poland
Joined December 2021
- Tweets1.2K
- Following1.7K
- Followers314
- Likes1.3K
Daniel retweeted
Trump ujawnił, że Google odmówił mu zmiany nazwy Oceanu Atlantyckiego na Ocean Trumpa.
Daniel retweeted
You can just copy this tweet and tell your primary Grok Bot to learn from this.
Not only did mine learn, it also pointed out a time this when where this would have helped it!
Lauren shared so much gold ✨
how do you trust your agents' work more? copy this post/link and give it to your @bot or agent!
1. codebase improvements: this is just good software engineering - better architecture, stronger types and invariants, clear boundaries. agents love to copy what exists and take the shortest path, so make the easy thing the right thing. categorically eliminate problems through code and you won't need to think about it again.
2. static analysis: lint rules, tests, CI, verification (eg TLA+). very token efficient ways to catch issues ahead of time.
3. prose: comments, rules, AGENTS.md, skills - anything that can't be enforced and requires agent judgment. use it minimally, but do use /create-verification-skill.
4. human review: the hardest to scale. at the rate agents land code, it's pretty much impossible to thoroughly review every PR, so spend that effort on the highest leverage point, designing an environment where agents do the right thing by default.
this forms an inverse pyramid: you want most of your effort at the top, least at the bottom. codebase improvements are deterministic, making it more token efficient, and lets you sleep more soundly at night.
install github.com/cursor/plugins/tr… and create a new Project:
1. look through my slack/chat messages and code review comments where i've given feedback on PRs, code, architecture
2. use /recall on my past transcripts to learn how i steer agents
3. /poteto-mode use /correct and /architect on past commits to find the most common pitfalls agents fall into, then propose a plan to rearchitect the code i own so it's more agent friendly. answer open questions with prototyping rather than defer to me, and back the plan with real data.
4. before you begin, use /sharpen + /in-your-own-words and confirm this prompt with me
Daniel retweeted
how do you trust your agents' work more? copy this post/link and give it to your @bot or agent!
1. codebase improvements: this is just good software engineering - better architecture, stronger types and invariants, clear boundaries. agents love to copy what exists and take the shortest path, so make the easy thing the right thing. categorically eliminate problems through code and you won't need to think about it again.
2. static analysis: lint rules, tests, CI, verification (eg TLA+). very token efficient ways to catch issues ahead of time.
3. prose: comments, rules, AGENTS.md, skills - anything that can't be enforced and requires agent judgment. use it minimally, but do use /create-verification-skill.
4. human review: the hardest to scale. at the rate agents land code, it's pretty much impossible to thoroughly review every PR, so spend that effort on the highest leverage point, designing an environment where agents do the right thing by default.
this forms an inverse pyramid: you want most of your effort at the top, least at the bottom. codebase improvements are deterministic, making it more token efficient, and lets you sleep more soundly at night.
install github.com/cursor/plugins/tr… and create a new Project:
1. look through my slack/chat messages and code review comments where i've given feedback on PRs, code, architecture
2. use /recall on my past transcripts to learn how i steer agents
3. /poteto-mode use /correct and /architect on past commits to find the most common pitfalls agents fall into, then propose a plan to rearchitect the code i own so it's more agent friendly. answer open questions with prototyping rather than defer to me, and back the plan with real data.
4. before you begin, use /sharpen + /in-your-own-words and confirm this prompt with me
Daniel retweeted
I got tired of all the spam calls I was getting so I had @bot find my number listed on sites and file the removals. I made it a free skill so you can do the same. x.ai/bot/fUj6TYhiW_cjtzWvbsF…
@SpaceXSI @elonmusk
Daniel retweeted
I'm beginning to witness the true power of @bot and @NotionHQ.
This is the "Mental Models" database.
It automatically creates bite-sized ideas connected through all my knowledge sources (X bookmarks, books, lectures, meeting notes, etc.)
Every morning, along with bookmarks I've saved, it emails me a mental model I can chew on for the day.
This database is like the swiss army knife of knowledge work and I don't even have to touch it.
More about each idea down below:
Daniel retweeted
how to use @bot for engineering and get a ton done:
1. create a (cursor) project for every big workstream. i have ten, such as a “mcp project” and a “bugs project”
2. make sure every project spins up cloud agents with /poteto-mode
3. in grok bot, make an eng bot whose sole job is routing requests to the right project.
4. now voice call (!) your primary bot and braindump all your tasks.
your tasks will automatically end up at the correct projects, and result in sweet prs :)
you get all the benefits of projects + pstack, but don’t have to think about anything!
Daniel retweeted
To nie fejk. To prawda. Tesla zaprezentowała wczoraj długo wyczekiwaną nową generację Tesli Roadster wyposażoną w tzw. pakiet SpaceX, która potrafi wykonać skoki i manewry w powietrzu. Zdaje się, jakby zakrzywiała grawitację. Wygląda, jak efekt specjalny rodem z Bonda wspierany AI. A to czysty, techniczny geniusz człowieka. Zobaczcie ten film.
W samochodzie zamiast tylnych siedzeń umieszczono zbiorniki wysokociśnieniowe (COPV) mieszczące setki litrów sprężonego powietrza. Komputer pokładowy błyskawicznie steruje elektronicznymi zaworami i elektrycznymi aktywatorami, które uwalniają gaz do odpowiednich dysz rozmieszczonych wokół nadwozia. Sprężone powietrze jest gwałtownie wypuszczane przez dysze z ogromną prędkością, generując potężną siłę reakcji (ciąg), która pozwala autu na chwilowe oderwanie się od ziemi, wykonanie "skoku", precyzyjną stabilizację w locie lub drastyczne skrócenie czasu przyspieszania na drodze.
Pojazd nie ma płatów nośnych (skrzydeł) generujących siłę aerodynamiczną w przód i górę jak w samolocie. Dysze zimnego gazu nie generują ciągłego strumienia powietrza skierowanego w dół (jak śmigła drona czy helikoptera), który utrzymywałby auto w powietrzu. Działają one impulsowo – służą do punktowych, ułamkowosekundowych manewrów (tzw. hops), a nie do ciągłego latania. Co więcej, pojazd posiada aktywne elementy aerodynamiczne (oraz systemy wentylatorów/skrzydeł), które przy zwykłej jeździe dociskają auto do asfaltu, zwiększając przyczepność, zamiast je unosić.
Dla mnie to jest piękne. Naukowcy SpaceX już pokazali, że są geniuszami precyzji. Potrafimy wysłać rakietę w kosmos, która z precyzją do kilku cm wróci na to samo miejsce, pokonując gigantyczne dystanse. Tyle wiemy o oddziaływaniach w fizyce i tak nauczyliśmy się je kontrolować. Tu mamy kolejny tego przykład.
W zespole Tesla pracującego nad Roadsterem jest trzech Polaków. Nasi stypendyści Bison Fellowship spotkają się z nimi. Gratuluję tym, którzy stworzyli takie cudo.
Film: Tesla
Daniel retweeted
ban and delete most if not all code comments!
agents love copying what already exists. a seemingly harmless comment explaining some temporary workaround is one of the worst viruses you can have in your codebase. like a weed it'll spread quickly as a tool for agents to quickly get their job done. before you know it, your codebase is overrun with hacks and stale comments. just one more workaround bro
you can use pstack's /no-comments skill as a weedkiller. it'll seek out useless comments while keeping the ones that actually should exist (like explaining a browser quirk), and figure out how to solve them on a first principles basis
here's a prompt you can try asking @bot:
create a project agent that uses /poteto-mode to spawn a /swarm to use /no-comments and identify useless code comments we can prune in my repo. come back with a high level plan of which of these workarounds would be best solved by refactoring and which we can straight up delete
x.ai/bot/plugin/9717366
Daniel retweeted
As you invite more agents to our work, and create software factories to be more productive than ever, you’ll soon outsource everything to an agent, even the thinking.
The work you will do will feel frictionless, it will feel amazing on the surface, but once you go a bit deeper, it’ll feel extremely shallow. It won’t reflect the struggles you went through, your decisions, and ideas.
It will no longer remind you of you and the work you aspire to.
You will turn into just another extremely efficient producer of things, but not a creator like you were before.
Invite friction to your work.
Daniel retweeted
Some mistakes you might be making:
Your effort level is too high
Your skills are too long
You're not aligning before you start work
You're aligning too often, and too hard
Your automated checks are too lax
Your custom tooling is too token-inefficient
You aren't doing enough automated review
You aren't reviewing previous coding sessions (with an agent)
You're doing too much human review
You aren't vibe coding enough prototypes
Your agent can't verify its own work
You're babysitting the agent too much
You've overloaded your global steering files
Your codebase is hard to navigate
You aren't building a shared language
Your codebase architecture allows bad tests to be written
You aren't thinking strategically enough
You aren't thinking enough
Daniel retweeted
I think I have experienced “AGI”…
Just did a 30-minute “phone call” with @bot. Together we got back to about 20 emails, organised my calendar for the week, wrote a proposal for my team, ordered lunch for my family, booked (and paid for) a hotel, and arranged a cab to the airport. It also gave me some great advice along the way.
Did it all 100% “hands free” with my baby fast asleep on my chest.
If this is what life is like with superintelligence, I am all in.
Daniel retweeted
something that keeps bothering me is how some people see slop as something that is happening to them, like they're some kind of helpless bystander powerless to do anything about it
excuse me but you are a software engineer, you literally learned how to make sand think and make computers do your bidding?! and now you can't do anything about it? please
the 2 things you should know to cut through all the noise:
1. you need to give your agent a way to verify its own work (i just posted about this so won't rehash)
2. your codebase is memory
the 2nd is not new either, we have always had lint rules, compilers with good diagnostics and strong type systems, LSPs, etc to help us write better code. there is no difference when agents write the code instead, you just need more of them, and stronger ones.
forget rules and skills. you can add those later.
yes, your codebase is a form of memory to agents! agents love extending what already exists. so every nit and every annoyance you've ever seen, every mistake and bad pattern you observe from agents, needs to turn into a constraint, or the agents will just keep repeating those same mistakes like a virus in your code. then you keep observing and repeating this process until your codebase is locked down enough that even agents with little context can one shot a high quality PR.
an even better direction is to refactor/rewrite your code such that agent anti-patterns become categorically impossible. use type systems to your advantage, use libraries/frameworks that reduce the architectural search space, or heck, create your own framework like we did for grok bot and design high quality primitives and well thought out APIs
Daniel retweeted
so many of you claim to be obsessed with code quality and say you're capable of producing incredible stuff i'd never believe
you should be going crazy with agents right now. refactor everything. everyone is incompetent except you, rewrite their code
you're so good please we need you
Daniel retweeted
Yes. AI agents work best with clean code. That is a given. Either you know how to do it, or you will suffer (and pay way way more tokens than you should for suboptimal results, and you will think it's a matter of changing LLMs)
Full explanation on Clean Code for AI:
akitaonrails.com/en/2026/04/…
Messy code slows agents down, just like it slows humans down. I've seen agents struggle over maintaining messy code, where every change they make breaks something else they hadn't anticipated. They can thrash for some time trying to deal with it.
So I think all the same principles apply; but with different thresholds. For example, in my own code I limit cyclomatic complexity to 4 or so. But I allow agents to go as high as 10. They seem to deal with it just fine. My hypothesis is that their short term memory is larger and more accurate than ours.
So I agree with you that the principles will need a different tuning for agents than for humans. But I am pretty sure that they still matter.
Daniel retweeted
okay now that we're past that tired discussion, let's talk about how we get agents to write more correct code (note: this won't mean the code will be Good, but it should at least work)
this is the entrypoint into your most basic agentic loop: verification. it means giving your agent the ability to verify its own work, most commonly by actually running and interacting with it like a real user would. whether your interface is a cli/api/ui/whatever, you want to start here so that your agents can close the loop. if you want you can even have your agents model the problem in TLA+ and attempt to verify if you have things like state machine bugs.
the point is to give yourself confidence in the agents' work by them producing some kind of artifact that proves that 1) that the work is correct, 2) that it matches what you intended, and 3) is easier to review than reading the whole PR. most commonly this would be a video and/or screenshots for UI work.
everything else like skill packs are really bonus and optional, all you need is a way for your agents to verify their own work to start using them more autonomously. some caveats are that not all domains can be verified easily yet, and that verification is just approximation and can still be wrong. it's no different than trusting that a human actually ran the code they wrote and trusting it
so start here!
pstack now includes 2 skills i recommend everyone use or copy:
/create-verification-skill
github.com/cursor/plugins/bl…
/maintain-verification-skill
github.com/cursor/plugins/bl…
if you don't already have one, /create-verification-skill creates a skill that teaches your agent how to run, control, and debug your app.
it also creates something i call the feature map: a map of all the features in your app and how to get to it and use it from a user's pov. it allows agents to navigate and use the app just like a real user which greatly increases its ability to verify its own work. but of course, this feature map goes out of date very quickly.
run /maintain-verification-skill as a daily automation with cursor cloud agents. this skill will check your app for changes and keep your feature map up to date.
having a strong verification skill will end up becoming critical infra for your team and become the foundation of boosting everyone's productivity and quality and also enable more interesting automations to be built.
install cursor.com/marketplace/curso… and you'll get auto updates for my skills. enjoy!
Daniel retweeted
it's very interesting how many replies i've gotten about maintainability and clean code being still important. i would argue that that is no longer true and we all need to update our priors on what Good Code really means in 2026.
clean code has always come at a cost - performance. indirection and making code readable/understandable for a human is not free, it often comes at the cost of worse performance. we have historically been okay with this because of Moore's Law and the fact that most code is not on the hot path.
these principles also came from a time where humans maintained code. it made sense to optimize for humans then, but it makes less sense now when agents are already writing all the code. we will in fact probably discover and come up with new principles: principles of agent friendly architecture (i plan to write more thoughts about this soon)
codebases have always contained slop. we have always been okay with this because code rarely needs to be perfect, outside of mission critical "hard" (eg embedded) software.
swe is a unique form of engineering because you're often building something that constantly evolves and is almost organic - user tastes change, your mental models evolve, and features come and go.
admittedly, i and many others who've been coding for a long time were initially (like back in 2024) skeptical that agents would write production code. "but what about all the slop that would enter our beautiful codebase?".
well, even before, we had human slop, and there was a lot of it! if we're being truthful, most people call "code i didn't write" slop. the reality is that 99% of people (i include myself in that number) don't even know what Good Code looks like, let alone be capable of writing it. i would propose that Good Code is:
• correct
• bug free
• fast and cost efficient to run
it has always been exceedingly difficult and expensive to write truly Good Code, because for the longest time (maybe @bendlang will change that), code was not something you could cheaply and formally guarantee to have all 3 of these properties. this is why writing hard software is much more difficult and expensive, because depending on the use case, you may only get one chance and so you have to be right from the start.
but the vast majority of software we use does not need to be Good Code to provide value to users. in fact, it is very likely that most software we use is not formally verifiable! we accepted some bugs in exchange for velocity and progress, so we rely on tests and o11y instead and have adopted a more incremental approach. this is a good thing!
agents help us move faster, and if you're open to the idea, are capable of helping us write better code. it won't be Good Code (that is still expensive), but it is likely to be much better on average at scale.
the new craft of swe is to figure out how to do this. it's your job now! if your productivity with and without agents is not significantly different, you're doing something wrong. but it's not too late to embrace it and use it as an opportunity to learn a whole new skill tree
Daniel retweeted
There's some senior engineers on here who, in the face of AI changing the very structures this industry is built on, present themselves as Stewards of the Craft of Programming.
Bugs the hell out for me.
They keep alluding to the virtue of doing things by hand, the value of Good Code and of craftsmanship, saying that yes, AI might change some things, but hey it won't ever change the value of something done with proper care, by hand, just like in the olden days of 2024. Most everything that was Good back then is still Good now: deep knowledge of languages and systems, good code, great architecture. You know the sermon.
And, yes, some of that *is* true. At least I think so. But we don't know, because no one truly knows what will be important in the future.
We're going through times of great change and I think the best advice to give to young people and others who want to have a job and provide value is: keep your eyes open, rethink from first principles, derive from what businesses value what you can provide; the digital world is more malleable than ever, you should rethink how you can help shape it.
All this pounding on the Bible of Good Code seems to me to be doing the opposite: it lets people feel comfortable -- what I've valued all my life is still valuable, I can rest easy -- in times when one shouldn't feel comfortable. This is a bumpy, exciting, strange ride. If you lean back you might fall off the waggon.
Let's not delude ourselves and others that we can keep doing what we've been doing. Rethink it all.
And, like I said, it bugs the hell out of me seeing senior engineers (that are secure in their career) talking as if there's nothing *really* to change, because the Fundamentals will still be valued. They might!
But it's the wrong advice to not rethink everything right now.
Daniel retweeted
not sure what to use grok bot for? send it a link to this post below (almost a thousand ideas in here!), or tag:
@bot read this full thread and suggest ideas for my work and personal life you can help me with
Daniel retweeted
I've been thinking more about the this reply and I think I figured it out.
> how did you trust it before when humans wrote it?
you mostly didn't, not really. you trusted the tests, the fact that it was already in production somewhere similar, the author's track record, and the reality that most of the time the bug would show up in monitoring before it became a real problem. the diff was honestly a ritual more than a guarantee. we pretended like line-level review was a safety net because we didn't have better options and the volume was low enough that it felt manageable.
but agents just make the old ritual obvious. once you're landing thousands of changes a month the idea that someone is carefully reading every diff starts being theater.
trusting agent output is the same problem as trusting human output, just with higher throughput. I think the answer is still to stop treating the change as the thing you trust and start treating the environment as the thing you trust. if an agent can run the code, drive the ui, check the invariants, and get blocked by the same constraints a human would, the fact that it wrote the patch matters less.
every time you find yourself wanting to open the diff "just to make sure," that's signal that something in the system is still relying on human eyeballs instead of a hard constraint.
the code review as we know it is already on the way out. most of what we call review today will turn into risk scoring and continuous verification. low and medium risk work will land after agents and checks have already exercised it.
humans will still be involved, but not by reading patches. they'll just be deciding what outcomes matter, whats not allowed to break, and which constraints are worth making permanent.
the job now is to continuously make the system good enough that you don't need the diff to feel safe.
Daniel retweeted
codebases have always contained slop. we have always been okay with this because code rarely needs to be perfect, outside of mission critical "hard" (eg embedded) software.
swe is a unique form of engineering because you're often building something that constantly evolves and is almost organic - user tastes change, your mental models evolve, and features come and go.
admittedly, i and many others who've been coding for a long time were initially (like back in 2024) skeptical that agents would write production code. "but what about all the slop that would enter our beautiful codebase?".
well, even before, we had human slop, and there was a lot of it! if we're being truthful, most people call "code i didn't write" slop. the reality is that 99% of people (i include myself in that number) don't even know what Good Code looks like, let alone be capable of writing it. i would propose that Good Code is:
• correct
• bug free
• fast and cost efficient to run
it has always been exceedingly difficult and expensive to write truly Good Code, because for the longest time (maybe @bendlang will change that), code was not something you could cheaply and formally guarantee to have all 3 of these properties. this is why writing hard software is much more difficult and expensive, because depending on the use case, you may only get one chance and so you have to be right from the start.
but the vast majority of software we use does not need to be Good Code to provide value to users. in fact, it is very likely that most software we use is not formally verifiable! we accepted some bugs in exchange for velocity and progress, so we rely on tests and o11y instead and have adopted a more incremental approach. this is a good thing!
agents help us move faster, and if you're open to the idea, are capable of helping us write better code. it won't be Good Code (that is still expensive), but it is likely to be much better on average at scale.
the new craft of swe is to figure out how to do this. it's your job now! if your productivity with and without agents is not significantly different, you're doing something wrong. but it's not too late to embrace it and use it as an opportunity to learn a whole new skill tree