sramam

Key things I like about Cursor (and I recognize I'm dating myself a bit here)

What a world we live in - "dating oneself" is measured in weeks/months! :)

These examples are going to be lagging indicators of the underlying sentiment.

Just because it cannot be done today, doesn't mean there is not a real appetite in large enterprises to do exactly this.

Without naming names, I know of at least one public company with a real hunger for exactly this eventuality.

What fraction of the remaining population would be able to pay for these services?

I work in enterprise IT and sometimes wonder if we should add the equivalent energy calculations of human effort - both productive and unproductive - that underlies these "output/cost" comparisons.

I realize it sounds inhuman, but so is working in enterprise IT! :)

Interesting - have you tried sending the image and 'hallucinated' text together to a review LLM to fix mistakes?

I don't have a use case of 100s or 1000s of hand-written notes have to be transcribed. I have only done this with whiteboard discussion snapshots and it has worked really well.

I think there is a difference between type system or Language Server completions and AI generated completion.

When the AI tab completion fills in full functions based on the function definition you have half typed, or completes a full test case the moment you start type - mock data values and all, that just feels mind-reading magical.

Aren't the insufficiencies of the LLMs a temporary condition?

And as with any automation, there will be a select few who will understand it's inner workings, and a vast majority that will enjoy/suffer the benefits.

do tools like cursor get a special pass? Or do they do some magic?

I'm always amazed at how well they deal with diffs. especially when the response jank clearly points to a "... + a change", and cursor maps it back to a proper diff.

I know very little in this field, but does this mean they the LED color is serving as debug/log messages for the training process? It sure seems so to my naive reading, and seems so clever.

    We use different LED lights to indicate transitions between dynamic modes
    in the automata. Similar to segmentation techniques in computer vision, 
    the learned hybrid modes can help us analyze motion patterns more 
    systematically, improve interpretability in decision-making, and refine
    control strategies for enhanced adaptability.

This is so funny!

However it can't even be called hallucinating. Imagine the incident "postmortem":

    But the AI was trained on White House press briefings

Have you looked at https://moondream.ai/?

Interesting take. Completely agree that product requirements document is a good mental models for system description. However, aren't bug-reports+PRs approximating a chat-interface?

That is a fair point.

This was the final technical screen so definitely something worth doing in my case.

The reason I posted a reply was there is a lot of negativity around AI in the hiring process. This was an excellent example of using AI to the benefit of all parties.

Instead of nit-picking on stylistic things from a smaller code-sample, one can nit-pick on the implemented complexity. I think it is a higher quality signal.

I recently completed a take-home assignment with the following instructions:

<instructions>

This project is designed to evaluate your ability to:

  - Deconstruct complex problems into actionable steps.
  - Quickly explore and adopt new frameworks.
  - Implement a small but impactful proof of concept (PoC).
  - Demonstrate coding craftsmanship through clean, well-architected code.

Feel free to use any tools, libraries, frameworks, or LLMs during this exercise. Also, you’re welcome to reach out to us at any time with questions or for clarification.

</instructions>

I used LLM-as-a-junior-dev to generate 95+% of the code and documentation. I'm just an average programmer, but tried to set a bar that if I was on the other side of the table, I'd hire anyone who demonstrated the quality of output submitted.

  - The 5-7 hour estimate was exceeded (however, I was the first one through this exercise). 
  - IMHO the quality of the submission could NOT have been met in lesser time.
  - They had 3 tasks/projects:
     - a data science project, 
     - a CLI based project and
     - a web app
  - They wanted each to be done in a different language. 
  - I submitted my solution <38 hours of receipt of the assignment. 
  - In any other world, the intensity of this exercise would cause a panic-attack/burn-out. 
  - I slept well (2 nights of sleep), took care of family responsibilities and felt good enough to attack the next work-day.

This was by far the most fun and one to replicate every chance I get.

[EDITS]: Formatting and typos.

vramework looks really well thought out. Is it in use by anyone yet?

using a different--and, ideally, new to me--language for each problem

Perhaps this is why?

I concur that asking devs how they use AI is a great idea.

Recently, I shared a code base with a junior dev and she was surprised with the speed and sophistication of the code. The LLM did 80+% of the "coding".

What was telling was as she was grokking the code (for helping the ~20%), she was surprised at the quality of the code - her use of the LLM did not yield code of similar quality.

I find that the more domain awareness one brings to the table, the better the output is. Basically the clearer one's vision of the end-state, the better the output.

One other positive side-effect of using "LLMs as a junior-dev" for me has been that my ambitions are greater. I want it all - better code, more sophisticated capabilities even for relatively not-important projects, documentation, tests, debug-ability. And once the basic structure is in place, many a time it is trivial to get the rest.

It's never 100%, but even with 80+%, I am faster than ever before, deliver better quality code, and can switch domains multiple times a week and never feel drained.

Sharing best AI hacks within a team will have the same effect as code-reviews do in ensuring consistency. Perhaps an "LLM chat review", especially when something particularly novel was accomplished!

Isn't this shortsighted in the sense that it removes all incentive for the creators to create?

A pre-click quality signal is more interesting and fair I imagine. Though I don't know how one can build a solution that is not game-able.

Very interesting. Thank you getting into the details. Do you chunk the text that goes into the BM25 index? For the hypothetical answer, do you also prompt for "chunk size" responses?

In the enterprise, the cost of failure to ones career/reputation is unreasonably high. pg's reference to "most skillful liars in the world" stuck out to me.

The extreme conservatism employed by managers to prevent failure - can only be summed up as "success at any cost". The consequence is decisions that spread the pain far and wide.

Unfortunately, these managers are not accountable for these consequences.

It's no winder that solutions take longer, cost more, are sub-optimal at almost every level. Furthermore, they very painful for the poeple who have to suffer these solutions. But hey, some unrelated manager-chain can claim success.

The worst of it is, these managers rinse-and-repeat at their next gig!

This is so cool.

Question (caveat: first export to treesitter and tools like this): Is there a reason the example demonstrates the use of depth as a variable instead of it being built in?

Nesting level of a particular "type" is general enough that it might be included OOTB. What you want to do with this might be generalizable - for example instead of

```

    enter section {
        depth += 1;
    }
    leave section {
        depth -= 1;
    }

    enter atx_heading {
        print("<h");
        print(depth);
        print(">");
    }
    leave atx_heading {
        print("</h");
        print(depth);
        print(">\n");
    }

It could simply be:

```

    enter atx_heading {
        print("<h");
        print(depth);
        print(">");
    }
    leave atx_heading {
        print("</h");
        print(depth);
        print(">\n");
    }

So depth is always of the nested levels of the same node type, but available out of the box. For markdown, it's headings, sections and lists come to mind - but I might be wrong.

In any event, this looks really well thought-out and now to checkout the other tools mentioned in the comments.....

I have always wondered if projects like this would be better off having a pay-as-you-go-model. One example:

  - Minimum account balance to start: $10.
  - $1/use 
  - Then top-off as you need 
  - no balance expiry (outside service going bust)

Doesn't that depend on what context a person knew you at - personal or professional?

The personal side typically will center on emotional aspects of being human. However what you do with your intellect is also a major part of being human. And that part is most often expressed only in our professional lives.

Celebrating a job well done and an outsized impact is a good thing - and if I may, the most "human" of things to do?

RIP.

This looks fantastic.

Just the notion of a hyperlinked code-playground is fantastic. Not to mention the content of the book.

And a side project at that? Wow. Congratulations and thanks for sharing.

You are arguing the difference between the letter and spirit of the law.

I am torn between marveling at the satire of this comment and crying at the truth it reveals

Have you considered LiteLLM?

This looks fantastic! Thanks for building.

Given that single projects are not that large, is there a reason you chose Postgres? I imagine using sqlite would reduce the installation complexity of the solution.

I wonder if the 5-6% is an accurate estimate.

Some back-of-the-envelope math:

- K-12 enrollment in 2021 was 49.4MM [1]

- Assuming even distribution across 13 grades, that's 3.8MM / academic year.

- 1MM ~= 25%, though if one factors in that drop-outs increase as years advance, this is conservative.

[1] https://nces.ed.gov/fastfacts/display.asp?id=372#PK12-enroll...

[edit] formatting

Modern JS (actually TS) tooling has adopted a middle ground. There is an instant feedback - un-type-checked version that runs (typically used in dev mode) with instant-feedback/hot-reload, and a slower compile and build flow that builds for production.

I was initially not very convinced of the benefits - why have a type-checker if you won't use it in the small? But IDEs provide much of the benefit inline while writing code and this is seldom a real problem from the DX perspective.

My skepticism was unwarranted.