Matt Dailey

try a balanced approach at ref.tools :)

I spent the last week experimenting with when to use HTML vs Markdown. The answer is: it depends. Data Visualization - 🏆 HTML. There's no comparison. This is a huge improvement. Custom intuitive graphics? Markdown could never. I guess data scientists are the new web developers lol. Prototyping - HTML. Sometimes a snippet of code is simply the best way to communicate an idea. Making that code snippet executable and meaningful to a human viewer to play with is a huge plus! Diagrams and flow charts - Markdown. You'd think HTML would win here but a Markdown viewer with Mermaid support is waaay better. I don't want an llm coding up a custom network diagram design when I already have a clean, standard, token-efficient way to view them. Hierarchical text - Markdown. Both HTML and Markdown have hierarchical text as a first-class feature. The reason is that this is the most standard way for us humans to absorb information. Sure an llm can write a beautiful HTML view of structured text but a clean Markdown viewer will be just as legible. And save tokens. So in the end, like all things with 2 reasonable options, if you only ever choose one, you're probably doing it wrong.

@zeeg the actually good thing every SaaS needs to build is something agents want to use (APIs, CLIs, MCP etc) the tension is that every SaaS business would sure love if you spent your token budget with them

vendor-specific chatbots are broken by design that means the Sentry agent, the Linear agent, and any others you might have in Slack they are fine for some point situations, they're nice to get started with, but agents with generalized access outperform them in every single scenario some weeks ago we built an internal Slackbot, gave it access to a bunch of systems (Sentry, GitHub, Linear, Notion, etc), and its capabilities overnight far exceed these other bots "Oh cool Linear can now search your code bases" - our bot did that on day one, and then could push that information wherever it needed to go. Its useful to the point where I now discourage use of things like the Linear bot because it _creates worse outcomes_. this also goes beyond the simple generalization of access: we can customize it. we throw in skills-as-runbooks, templates, etc and the outcomes once again incrementally improve if your org hasnt already built a general purpose bot internally you should. if you need inspiration ours is open source on GitHub (albeit fairly unstable still) github.com/getsentry/juni…

After 1.5 years solo, @ref_tools has a second person. @suvir_ was my second hire at Figma, and getting to work with him again feels like a gift. Phenomenal engineer, one of the most thoughtful people I know, exactly who you want shaping a company's culture from day one. So glad he's here.

the 5 mediocre features are the real debt

@karrisaarinen @jeiting this is it. better to build 60 versions of the same app than 60 different apps

@jeiting still want to see how people actually do it. I think better comes from focusing on one thing hard trying to be make it better, not building 60 apps in one month.

What if we built better software, not just more of it?

I love the push that "my diffs are too large" signifies slop! Although I disagree on another part. Lossy markdown are the best way to de-slop / avoid slop we can trust coding agents to crush when given the right abstractions. the plan should be pulling out the key decisions so the human (and the rest of the human team!) give agents what they need to not screw up.

Code is actually the right abstraction. Too often I see the future of software engineering diminished down to, effectively, writing and reviewing markdown files. Yes, it will be hard to review thousands of lines of agent code. But maybe the takeaway is that you want less code? Rather than just giving up ("well I guess we won't read the code, or we'll read this lossy markdown summary") this should be a signal forcing you to think about better systems. - How can we make our codebase more verifiable? For example, fast/robust/stable tests, or moving to a typed language. - How can we deslop or improve the architecture/abstractions of the code generated by agents? For example, spending more time up front on the codebase architecture/types before yolo generating all of the code. - How are we going to maintain and evolve this codebase over time? The slop compounds. One great solution here is... you guessed it, learning from the past decades of software engineering! For example, you might just have the wrong abstraction entirely, leading to a ton of duplicated code. I think the markdown folks *are* right in some ways. If you are using skills every day, for many different prompts and workflows, isn't that effectively "coding with markdown"? Kinda. There's been plenty of ink spilled on the merits and benefits of skills. To me, skills make your style of working legible for agents. They don't replace code and that's not really the point. In reality, there's this messy and constantly re-evolving future in which both of these things are true: 1. Skills (and markdown) are important for how you give input to the agents and ensure high-quality code & systems are created 2. Looking at the actual code will not be replaced by markdown summaries or a collection of spec documents that ignore the lower level details of the code In summary: reality has a surprising amount of detail (and nuance)!

you don't need to declare agent bankruptcy everyday i get it, it's fun to feel bourgeoisie and just toss aside an agent that you don't even remember why you launched but you really don't need to. switch your work from plans to chats. its that easy. and your brain will thank you

for sure A! I think of the spec is a descriptions of changes I want to make to the system That means it has: 1. a description of the end-state behavior, the goal of this change 2. a well-researched understanding of the prior state 3. a outline of how get to the goal a purist might say the spec is only #1 and the agent should fill in the gaps but imo that's leads to way more re-work

If you are following Spec-Driven Development (SDD), how do you handle changes in existing functionality/feature? A) Create a new spec with the intended change and let AI implement it. B) Update existing spec about that Feature/UseCase/Epic and let AI figure out what needs to be done and implement it. What is the reason you chose one option over the other?

i like this framing. I've been working solo for a year+ and my backlog and sprint planning are all just a doc I'm just about to bring on my first few teammates and have been waffling about porting all my notes to linear/asana OR trying to extend my doc system this is a nice push to keep it simple!

sometimes when I swap between agent chats I get the "why did I walk in here" feeling

"The risk is that AI does the work and we never learn from it" this is how we don't leave the junior engineers behind

@SPLehman @charlieholtz ❤️2️⃣👂

@reactiverobot @charlieholtz 🔜⏳

Run a team of coding agents... in the cloud

your planning tool should make you happy

every time i feel stressed about work i remember a clip of the artemis team says "we're just going to do this with as much joy as possible" Their mission was don't die in space mine is build software so other people can build software better. i can take a breath and have fun

could. not. agree. more!

our tools need to be built from the ground up to combat cognitive surrender