oxidant

Interesting question. From the Wikipedia article,

ISO 8601 allows Gregorian dates from the introduction of the calendar on 15 October 1582.

https://en.wikipedia.org/wiki/ISO_8601#Dates

This works well for jobs that are long-ish. You need another process to sweep for orphaned jobs and requeue or fail them. Add a timestamp of when it got picked up to keep track

Exactly the point I was going to make. Shipping something requires knowing how to ship it, monitor it, and fix it.

Writing code is the "easy" part and kind of always has been. No one triggers incidents from a PR that's been in review for too long.

Electron ships a version of Chrome. Other frameworks like Tauri use the device's webview.

receive takes a timeout. A would crash/hit the timeout and deal with the problem.

What do you mean, "creates a Conn variable out of whole cloth"?

Conn is just a pipeline of functions, the initial Conn struct is created at request time and passed through to each function in the pipeline.

I've never seen it write a file in plan mode either.

The behavior is configurable and the default is unbound.

https://www.erlang.org/doc/apps/erts/erl_cmd.html#%2Bsbt

Not if the items change relative position over time.

Schroedingers branching

Counterpoint: Why should my println debugging get committed? They're not "important" for the final product but important for development.

Agreed, but people sell "vibe coding" without acknowledging you need more than vibes.

LLMs can help answer the questions. However, they're not going to necessarily make the correct choices or implementation without significant input from the user.

Of course that's what the industry is selling because they want to make money. Yes, it's easy to create a proof of concept but once you get out of greenfield into 50-100k tokens needed in the context (reading multiple 500 line files, thinking, etc) the quality drops and you need to know how to focus the models to maintain the quality.

"Write me a server in Go" only gets you so far. What is the auth strategy, what endpoints do you need, do you need to integrate with a library or API, are there any security issues, how easy is the code to extend, how do you get it to follow existing patterns?

I find I need to think AND write more than I would if I was doing it myself because the feedback loop is longer. Like the article says, you have to review the code instead of having implicit knowledge of what was written.

That being said, it is faster for some tasks, like writing tests (if you have good examples) and doing basic scaffolding. It needs quite a bit of hand holding which is why I believe those with more experience get more value from AI code because they have a better bullshit meter.

I do not agree it is something you can pick up in an hour. You have to learn what AI is good at, how different models code, how to prompt to get the results you want.

If anything, prompting well is akin to learning a new programming language. What words do you use to explain what you want to achieve? How do you reference files/sections so you don't waste context on meaningless things?

I've been using AI tools to code for the past year and a half (Github Copilot, Cursor, Claude Code, OpenAI APIs) and they all need slightly different things to be successful and they're all better at different things.

AI isn't a panacea, but it can be the right tool for the job.

Not OP but probably just cost.

Elixir has a better developer experience, or at least it's more approachable. Better code splitting with modules, easier to use variables (no var, var1, var2), loops that look like loops but easy enough to fall back to recursion, and an easier to read syntax.

gen_stage is just a library. One could write it in Erlang. It's like asking why Broadway is only for Elixir and not Erlang.

It was hard to approach the Erlang docs when I started in Elixir. However, they've moved to an ex_doc format (is it ex_docs?) as a standard and it's so much easier to grok.

FOR UPDATE SKIP LOCKED is great, but it needs to be in a transaction. In the example code it won't "do" anything because it selects for update then immediately loses the lock.

Claude says you can use a CTE to select and the run your update with the locked rows, but I have only ever used transactions.

Better to use something like OpenApi and generate your zod schema using it.

It's JSON-RCP 2 with a specific life cycle and events. https://www.jsonrpc.org/specification

I found an explanation on a site once but haven't found any official docs. I suppose you could reverse enegiener the SDKs.

I wish there was a clear spec on the site but there isn't https://modelcontextprotocol.io/specification/2025-03-26

It seems like half of it is Sonnet output and it doesn't describe how the protocol actually works.

For all its warts, the GraphQL spec is very well written https://spec.graphql.org/October2021/

I think Bill Nye has something similar, too.

The grandparent is talking about how to control cost by focusing the tool. My response was to a comment about how that takes too much thinking.

If you give a junior an overly broad prompt, they are going to have to do a ton of searching and reading to find out what they need to do. If you give them specific instructions, including files, they are more likely to get it right.

I never said they were replacements. At best, they're tools that are incredibly effective when used on the correct type of problem with the right type of prompt.

Multiple terminal sessions. Well written prompts and CLAUDE.md files.

I like to start by describing the problem and having it do research into what it should do, writing to a markdown file, then get it to implement the changes. You can keep tabs on a few different tasks at a time and you don't need to approve Yolo mode for writes, to keep the cost down and the model going wild.

Think about what you would do in an unfamiliar project with no context and the ticket

"please fix the authorization bug in /api/users/:id".

You'd start by grepping the code base and trying to understand it.

Compare that to, "fix the permission in src/controllers/users.ts in the function `getById`. We need to check the user in the JWT is the same user that is being requested"

The licenses for the Microsoft extensions explicity don't let you use them in non-MS editors. They seem to be cracking down now.

To be fair, Copilot came before Cursor and the "agent mode" isn't a Cursor specific feature.

I use Cursor every day but I'm more than happy to switch if a better tool exists.

Spreading arrays and objects is such a common performance hit. It works fine for small instances but falls over in large instances.

Here's the JS CRM engine https://github.com/nuejs/nue/blob/master/packages/examples/s...

I see a number of issues, but don't have time to look into them.

1. Spreading when you probably don't need a copy: sortEntries. Sorting is probably where the overflow happens. Just sort in place or use Array.from or slice.

2. Excessive use of array functions. In my experience, a C style for loop performs better when you need performance. Create an empty array before, perform your business logic inside the block, and push to the array.

3. I don't know how filter is called, but it potentially loops through all of the events three times in the worst case.

4. paginate manually creates a JSON string from the returned entries. I don't know why, it seems inefficient.

WordPress, despite all of the current drama, is an example of an open source project with many different competitors and development seems to move just fine.

Creating an artificial moat and misrepresenting capabilities, as outlined in the article, may bring value to Vercel, but it can hurt consumer confidence. I would not and have not chosen Next for projects because of the lock in.

You're off by three orders of magnitude. 3k lines. You also don't know what the wrapper does.

I've had similar issues and the trick I've found is to jump to Google/SO to find examples or docs as soon as Claude stops making progress.

If you got NullValueHandling, jumping to the library documentation would give you immediate accurate results.

Your post suggests authorization as a feature:

For each replay that we run, Roark checks if the agent follows key flows (e.g. verifying identity before sharing account details)

I don't know if AI will be more susceptible or less susceptible to phishing than humans, but this feels like a bad practice.