Back when I was handling it, we were still using Flash for most of the interactive tests, because that was how you had to do it when it was first built circa 2007. Obviously those would have had to be redone in HTML5 since then to keep it working on modern browsers.
I simply don’t agree with the conclusion though I appreciate the approach to thinking about products.
I recently chose to take the train vs driving and the factors behind that decision were:
* Time, yes. Train was approximately the same but an actually a bit slower.
* Cost. Train was slightly cheaper when looking at the true cost of driving. Also significantly cheaper than flying.
* Experience. This is entirely overlooked in the timetable centric approach. Train is simply the most pleasant way to travel long distances (maybe ferry is competitive there). I was able to move around and get work done and enjoy the view. If the train company had swapped my train for a bus I would NOT have been a satisfied customer.
* City center to city center (vs airport to airport). Had the train company said “we swapped the arrival location to the airport but technically we still got you to the city” I would NOT have been a happy customer.
The “trains as timetables” hypothesis would imply that the train could meet my needs via something other than rail travel and would definitely lose me as a customer.
On the other hand, improvements such as better wifi service (it was terrible and not sure why cell service is also poor on a train) or a route that was more scenic but did not impact my arrival time significantly would positively affect my likelihood of choosing train.
So the better lesson is know your customer needs and know their specific jobs to be done and center your hypothesis around this.
I think a lot of that is colored by the fact that you were doing a long-distance trip. I would completely agree with your points if I were, say, living in Frankfurt and planning a holiday in Paris.
But the math is a lot different for regular day-to-day trips, and for that I do think the timetable is the primary product. My goal is to get from A to B, and do so 1) reliably, 2) quickly, and 3) affordably. I don't really care if this means taking the car, the bus, the underground, the train, my bicycle, or a ferry - I'll use whatever option is most convenient.
If I'm only in/on there for 30 minutes, I could not care less for a scenic view. It matters far more whether there is a frequent service I can rely on, which doesn't involve half a dozen needless busy-work with transfers and endless waiting and anxiety for each connecting service. The more it acts like a taxi, the happier I am.
I’ve often thought this would be useful for version control and change review, since it allows diffs to be a lot less noisy. I’m imagining how much easier it would be to review a PR with significant README edits if the file was already structured with semantic line breaks.
I’ve previously had the above thought and applied it to the end of sentences, but the idea of introducing them at the level of semantic thought had not occurred to me. But if this is where we’re going I’d start to wish for indentation possibilities. I’ve do this frequently with SQL statements, introducing both line breaks and indentations to provide a visual structure that mimics the semantic structure of clauses and the details they contain.
Indeed. Edits show up as a -/+ on just the sentence or clause that has changed. Contrast with hard-wrapped text, where a single word change towards the beginning of a paragraph can cause the entire paragraph to be replaced in the diff view, as things reflow.
My father had his eyes fixed like this about a decade ago and purports to be happy with it.
IIRC they did actually require that he wear contact lenses that replicated the effect for some amount of time (a month or so I believe) because there are people who are not happy with the arrangement. So they sort of force you to try before you buy.
Agreed. Many animals without language show evidence of thinking (e.g. complex problem solving skills and tool use). Language is clearly an enabler of complex thought in humans but not the entire basis of our intelligence, as it is with LLMs.
But having language as the basis doesn't mean it isn't intelligence, right? At least I see no argument for that in what's being said. Stability can come from a basis of steel but it can also have a basis of wood.
LLMs have no intelligence or problem solving skills and don't use tools. What they do is statistically pattern match a prompt against a vast set of tokenized utterances by humans, who do have intelligence and complex problem solving skills. If the LLM's training data were the writings of a billion monkeys banging on typewriters, any appearance of intelligence and problem solving skills would disappear.
Much of this post was spot on — but the blind spots are highly problematic.
In this agentic AI utopia of six months from now:
* Why would developers — especially junior developers — be assigned oversight of the AI clusters? This sounds more like an engineering management role that’s very hands on. This makes sense because the skill set required for the desired outcomes is no longer “how do I write code that makes these computers work correcty” and rather “what’s the best solution for our customers and/or business in this problem space.” Higher order thinking, expertise in the domain, and dare I say wisdom are more valuable than knowing the intricacies of React hooks.
* Economically speaking what are all these companies doing with all this code? Code is still a liability, not an asset. Mere humans writing code faster than they comprehend the problem space is already a problem and the brave new world described here makes this problem worse not better. In particular here, there’s no longer an economic “moat” to build a business off of if everything can be “solved” in a day with a swarm of AI agents.
* I wonder about the ongoing term scaling of these approaches. The trade off seems to be extremely fast productivity at the start which falls off a cliff as the product matures and grows. It’s like a building that can be constructed in a day up to a few floors but quickly hits an upper limit as your ability to build _on top of_ the foundational layer of poorly understood garbage.
* Heaven help the ops / infrastructure folks who have to run this garbage and deal with issues at scale.
Btw I don’t reject everything in this post — these tools are indeed powerful and compelling and the trendlines are undeniable.
Does it operate by translating your higher level AI methods into lower level Playwright methods, and if so is it possible to debug the actual methods those methods were translated to?
Also is there some level of deterministic behavior here or might every test run result in a different underlying command if your wording isn’t precise enough?
It's a little hacky, but we have a method in the act() handler called performPlaywrightMethod that takes in a playwright method + xpath and executes the playwright method on the xpath. There's definitely a lot of room for improvement here, and we're working on making observe() fill those gaps. I think observe() aims to be like GitHub Copilot's gray suggested text that you can then confirm in a secondary step; whereas act() takes on a more agentic workflow that you let the underlying agent loop make decisions on your behalf
This is just outstanding. It's so exactly what I wish for out of a scratch pad.
My feature request to add to your pile (possibly a lonely one, since maybe it's just unique to how my brain works):
I really want a scratch pad like this to have UX that supports "inverted" order. Meaning, new blocks get added to the top of the page instead of the bottom. The blocks naturally flow in descending order of creation rather than ascending. The scratch pad always opens at the top of the page. Over time, blocks thus end up "decaying" toward the bottom, with the most relevant at the top.
It just fits better with how my brain works.
I also +1 the sentiment given elsewhere in this thread to bias toward ignoring the vast majority of these feature requests and preserve the simplicitly of what you've built. That includes mine!
I get the idea of the "inverted order". I wonder if it would be enough to make it configurable so that C-Enter inserts a new block before the current one + Heynote sets the cursor at the beginning of the buffer at startup (instead of last which is the current behavior)?
Another option might be to have the default scroll position at the bottom, to act more like a terminal or chat app. Scroll up to see the history, rather than scrolling down to see the latest.
(Sorry if this is how it already works, I’m on my phone right now, so I can’t download it, but I’m very interested in the block idea. I like that concept a lot for a scratch pad. I’m definitely saving this for later.)
Yeah I was thinking similar. And/or a separate shortcut key that opens a new block at the very top of the page (regardless of where the current cursor is positioned).
Your app is awesome, it's just so satisfying to use. Really fantastic job!
My two cents on block insertion: Personally, I would love if Cmd+Enter inserts a new block at the very top
For inserting a new block in sequence, I feel like Cmd+Shift+Enter (splitting the current block) might already be enough - but I obviously haven't used heynote for long enough to have a very informed opinion on this :)
Maybe there's some way to make the behavior configurable?
I also like this. But I don't like the distraction of seeing all the blocks below my cursor move every time I make a new line.
The perfect UX would be to add a new buffer at the top, but with enough padding to fill the window so that you can't see the movement of previous blocks while you're typing.
(Maybe this is already kinda how it works - I haven't downloaded the app yet, but I'm excited to try it, because it looks great!)
I wrote a small Ruby TUI which works like this called Rodo (Ruby Todos). Pressing CTRL+t will get you a new Todo list (it's just markdown) at the top of a file.
In a regular doc, if you start typing at the beginning, then all the lines after it move down as you type. It's just the movement I find distracting, compared to appending to a doc with no space below where I'm inserting text. I'd rather feel like I'm typing into empty space rather than up against a wall.
I made a notes app that's kind of like that. Notes get added to the top and when you edit a note it gets "bumped" to the top again: https://thinktype.app/
A web page that can run offline is typically called a web app. With some metadata it is possible to "install" them to run in ui chrome less windows like a natively installed app on multiple environments.
It's not the .app domain so much as the functionality. Web apps are nicer and easily accessible imo, lower friction than an install. Not everything should need an install.
You're somewhat right. However, I would hesitate to call any website an app. And there certainly is a difference. For one thing I would say an app must be it's own program, even if it just uses Electron or similar.
My advice to you (at least what's worked for me on several reasonably well-functioning teams using stories and Jira in a similar manner as you have described:
Decouple users stories (customer/product outcomes) from tasks (units of work needed to achieve those outcomes). Jira is designed pretty well for this, since you can have sub tasks attached to user stories.
This works better when your user stories _are_ actually defining outcomes -- for example when you have stories like "User admins can filter jobs by category" and not "Build a category filter for the job search." The first can usually be successfully defined by a few acceptance criteria, whereas the second starts to get weird since you're focus is more on what it will take to build the thing vs. what is the result you want your customer to see.
With your outcome defined in the story you can define any number of implementation tasks it will take to achieve it. If you're a cross-functional team and you do "vertical" instead of "horizontal" splitting then you're sure to have a few coding tasks on the front end ("add the filter component to the search bar", "update the backend client to pass the category id as a query parameter") as well as a few on the backend ("update the API to accept the category parameter", "add the category param to the repository query service"). You probably have some non technical tasks too ("update the help documentation", "update the OpenAPI spec").
We almost never (save for absolutely trivial user stories) have a PR attached to the story but instead have PRs attached to sub tasks. If you're doing trunk based development with continuous deployment and feature flags, you can and should be shipping many PRs. Just yesterday I was in the middle of a task at the end of the day and decided to cut the PR where I was and split the task in two on the fly, since it was easier for me to ship the code like that and easier for my team to review it.
We do story grooming and estimation and all that -- but only for user stories. Tasks are the domain of the humans doing the work and they are meant to be flexible and even disposable. We usually have a session at the start of work on the user story when the engineers working on it align on the solution and then break the work down in to sub tasks, but these naturally evolve as the work progresses. I should had that multiple tasks invite collaboration instead of one story per engineer.
Lastly, I've found you have to preach the virtues of small PRs to your team and usually convert a few stragglers who don't see the value. I try to practice what I preach (i.e. by keeping my own PRs small) and also make a big deal out of it in retrospectives -- i.e. point out how painful the review process is with large PRs, usually entailing many rounds of comments and changes -- so that people quickly become believers if they are not already.
As a last point I try to encourage the value of "PR reviews are your top priority at any given moment" since every second a piece of code sits unreviewed adds to your team's cost of delay. There's a virtuous cycle here where smaller PRs lead to less painful code reviews lead to greater willingness to spend 10 minutes (vs. an hour) doing a code review, which helps really get PRs moving through.
I think PR stacking is great but I also find it's not as important if your PRs are getting reviewed and approved faster than you can write the code for your next PR.
(I didn't realize I'd write so much here, I forget that it's actually kind of a big topic that's built on a variety of different practices that all start coming together at some point when you get in a groove.)
Thanks! How do you integrate QA and merging with that? Do you QA and merge each subtask PR independently? Or do you leave all subtasks unmerged in favor of QA'ing the entire story, at which point you merge all PRs?
This is where feature flags come in. When you use feature flags to support development you ship code straight to production — but your work is hidden behind that glad while development is under way. So in practice you merge your PRs immediately to master (and deploy).
Essentially you’re decoupling release from development here. This supports any number of QA practices. (We don’t have dedicated QA at the moment and instead have a biweekly “mob QA” session where we do a group deep dive into our current work.) We will capture most small fixes and improvements as sub tasks on the appropriate story (or file a bug ticket if the story was already done and we discovered a new issue.)
As a result of the above we don’t use long lived feature branches which become painful and slow, process wise. We just merge immediately after review. (Unmentioned but this is of course supported by automated testing and continuous deployment.)
Thanks, this is super helpful. For us, we are pretty heavy with manual QA, and for work that can't be wrapped in feature flags, we'd still have to test a fair amount before merge, but at least it wouldn't have to be for every PR.
For post-release QA, at what point do you close the story? After all the subtasks are merged/deployed? Or later, after QA is done and they turn on the feature flag?
