That made me laugh. True, but not really the motivation. I honestly don't think LLMs can code significant real-world things yet and I'm not sure how else to prove that since they can code some interesting things. All the talk about putting programmers out of work has me calling BS but also thinking "show me". This task seems like a good combination of simple requirements, not much documentation, real world existing problem, non-trivial code size, limited scope.

Tom Sawyer? Yes.

Very much this. When you criticize LLM's marketing, people will say you're a ludite.

I'd bet that no one actually likes to write code, as in typing into an editor. We know how to do it, and it's easy enough to enter in a flow state while doing it. But everyone is trying to write less code by themselves with the proliferation of reusable code, libraries, framework, code generators, metaprogramming,...

I'd be glad if I could have a DAW or CAD like interface with very short feedback (the closest is live programming with Smalltalk). So that I don't have to keep visualizing the whole project (it's mentally taxing).

i kinda think "javacript, the good parts" should be part of the prompt for generating TS and JS. I've seen too much of ai writing the sketchy bad parts

You're right, instead what we see is the emergence of "vibe coding", which I can best describe as a summoning ritual for technical debt and vulnerabilities.

Something is happening, its just not exciting as some people make it sound.

That's like saying that you're judging a sedan by its capability of performing the job of a truck.

Wait, you were being sarcastic?

I've outlined a function for that and started to write the code. At a high level it's straight forward, but the details are complex. It'll probably be a year before it's done.

>> And a way to define parameters (not sure if that's already possible).

This is an active work in progress. A demo was made years ago, but it's buggy and incomplete. We've been working out the details on how to make it work. I hope to get the units issue dealt with this week. Then the relation constraints can be re-integrated on top - that's the feature where you can type arbitrary equations on the sketch using named parameters (variables). I'd like that to be done this year if not this summer.

They won't touch this.

Yes. I did a lot of the 3->4 prep work. But there were so many API changes... I attempted to do it by commenting out anything that wouldn't build and then bring it back incrementally by doing it the GTK4 way. So much got commented out that it was just a big mess of stubs with dead code inside.

I suspect the right way to do it is from scratch as a new platform. People have done this, but it will require more understanding of the paltform abstraction and how it's supposed to work (It's not my area of the code). I just want to "convert" what was there and failed.

https://github.com/solvespace/solvespace?tab=readme-ov-file#...

Doing the second part is to my understanding actually the purpose of the stated task.

I'd like to use the same UI on all platforms so that we can do some things better (like localization in the text window and resizable text) and my preference for that is GTK. I tried doing it myself, got frustrated, and stopped because there are more important things to work on.

The fact that they haven't done the port in the normal way suggests they basically agree with what you said here (not worth the ROI), but hey if you can get the latest AI code editor to spit out a perfectly working port in minutes, why not?

FWIW, my assessment of LLMs is the same as theirs. The hype is far greater than the practical usefulness, and I say this as someone who is using LLMs pretty regularly now.

They aren't useless, but the idea that they will be writing 90% of our code soon is just completely at odds with my day to day experience getting them to do actual specific tasks rather than telling them to "write Tetris for XYZ" and blog about how great they are because it produced something roughly what I asked for without much specificity.

I respectfully disagree with that. I think it's a solid UI framework, but...

>> It's openly hostile to not consider the upgrade path of existing users, and make things so difficult that it requires huge lifts just to upgrade versions of something like a UI framework.

I completely agree with you on that. We barely use any UI widgets so you'd think the port would be easy enough. I went through most of the checklist for changes you can make while still using GTK3 in prep for 4. "Don't access event structure members directly, use accessor functions." OK I made that change which made the code a little more verbose. But then they changed a lot of the accessor functions going from 3 to 4. Like WTF? I'm just trying to create a menu but menus don't exist any more - you make them out of something else. Oh and they're not windows they are surfaces. Like why?

I hope with some of the big architectural changes out of the way they can stabilize and become a nice boring piece of infrastructure. The talk of regular API changes every 3-5 years has me concerned. There's no reason for that.

  I understand the desire for a simple or unconventional solution, however there are problems with those solutions.
  There is likely no further explanation that will be provided.
  It is best that you perform testing on your own.

  Good luck, and there will be no more assistance offered.
  You are likely on your own.

My proposed solution was to just drop all incoming SOCKS traffic until the tunnel was up and running, but Gemini was hooked on the idea that this was a sluggish way of solving the issue, and wanted me to drop all outgoing traffic until the tun device existed (with the exception of DNS and VPN_PROVIDER_IP:443 for building the tunnel).

It feels like an upgrade from 3.5

The latest updates, I’m often like “would you just hold the f#^^ on trigger?!? Take a chill pill already”

What did it do?

A COMPLETE FUCKING REWRITE OF THE MODULE.

The result did work, because of unit tests etc. but still, it has a habit of going down the rabbit hole of fixing and changing 42 different things when you ask for one change.

Meanwhile, the 'experts' are saying something entirely different and being told they're wrong or worse, lying.

I'm sure you've seen it before, but this propaganda, in particular, is the holy grail of 'business people'. The ones who "have a great idea, just need you to do all the work" types. This has been going on since the late 70s, early 80s.

This is called "paraconsistent logic":

* https://en.wikipedia.org/wiki/Paraconsistent_logic

* https://plato.stanford.edu/entries/logic-paraconsistent/

Yes people claim that but everyone with a grain of salt in his mind know this is not true. Yes, in some cases an LLM can write from scratch a python or web demo-like application and that looks impressive but it is still far from really replacing a SWE. Real world is messy and requires to be careful. It requires to plan, do some modifications, get some feedback, proceed or go back to the previous step, think about it again. Even when a change works you still need to go back to the previous step, double check, make improvements, remove stuff, fix errors, treat corner cases.

The LLM doesn't do this, it tries to do everything in one single step. Yes, even when it is in "thinking" mode, in thinks ahead and explore a few possibilities but it doesn't do several iterations as it would be needed in many cases. It does a first write like a brilliant programmers may do in one attempt but it doesn't review its work. The idea of feeding back the error to the LLM so that it will fix it works in simple cases but in most common cases, where things are more complex, that leads to catastrophes.

Also when dealing with legacy code it is much more difficult for an LLM because it has to cope with the existing code with all its idiosincracies. One need in this case a deep understanding of what the code is doing and some well-thought planning to modify it without breaking everything and the LLM is usually bad as that.

In short, LLM are a wonderful technology but they are not yet the silver bullet someone pretends it to be. Use it like an assistant to help you on specific tasks where the scope is small the the requirements well-defined, this is the domain where it does excel and is actually useful. You can also use it to give you a good starting point in a domain you are nor familiar or it can give you some good help when you are stuck on some problem. Attempt to give the LLM a stack to big or complex are doomed to failure and you will be frustrated and lose your time.

Makes one wonder how much they are offering to the owner of www.copilot.com and why on God's green earth they would abandon the very strong brand name "Office" and www.office.com

these days it seems like everyone is trying to get their AI to be the standard.

i wonder how things will look in 10 years.

[1] https://www.cio.com/article/3586887/marc-benioff-rails-again...

[2] https://techcommunity.microsoft.com/discussions/microsoft365...

The recording of adding support for 100+ new coding languages with tree-sitter [1] shows some pretty advanced usage. It includes using aider to script downloading a collection of files, and using ad-hoc bash scripts to have aider modify a collection of files.

[0] https://aider.chat/docs/recordings/

[1] https://aider.chat/docs/recordings/tree-sitter-language-pack...

I hear people commonly mention doing this but I can't imagine people are manually adding every page of the docs for libraries or frameworks they're using since unfortunately most are not in one single tidy page easy to copy paste.

This approach yields more upvotes and views on their website, which ultimately leads to increased conversions for their tool.

1. Design chats: they help a lot as a counterpart to detect if there are flaws in your reasoning. However all the novel ideas in Vector Sets were consistently found by myself and not by the models, they are not there yet.

2. Writing tests. For the Python test code, I let the model write it, under very strict prompts explaining very well what a given test should do.

3. Code reviews: this saved myself and future users a lot of time, I believe.

The way I used the model to write C code was to write throw away programs in order to test if certain approaches could work: benchmarks, verification programs for certain invariants, and so forth.

They can be. The cloud-hosted LLMs add a gratuitous randomization step to make the output seem more human. (In vein with the moronic idea of selling LLM's as sci-fi human-like assistants.)

But you don't have to add those randomizations. Nothing much is lost if you don't. (Output from my self-hosted LLM's is deterministic.)

I'd be a bit suspect of an LLM getting an emulator right, when all it has to go on is docs and no ability to test (since pass criteria is "behaves same as something you don't have access to")... Did you check to see the degree to which it may have been copying other NES emulators ?

1. Cursor Pro with Sonnet to implement things the Cursor way.

2. Install the Gemini Code extension in Cursor.

3. Install the Gemini Coder Connector Chrome extension: https://chromewebstore.google.com/detail/gemini-coder-connec...

4. Get the free aistudio.google.com Gemini API and connect the extensions.

5. Feed your codebase or select files via the Cursor extension and get the implementation from aistudio.google.com.

I prefer having Sonnet implement it via Cursor rather than Gemini because it can automatically go through all the linting/testing loops without my extra input, run the server, and check if there are no errors.

When providing the flat format it was able to replicate it without much instructions for a blank prompt i had success with the prompt below

===FILE=== Index: 1 Path: src/main/java/com/example/myapp/Greeter.java Length: 151 Content: package com.example.myapp;

public class Greeter { public String getGreeting() { return "Hello from the Greeter class!"; } } ===ENDFILE=== ===FILE=== Index: 2 Path: src/main/java/com/example/myapp/Main.java Length: 222 Content: package com.example.myapp;

public class Main { public static void main(String[] args) { Greeter greeter = new Greeter(); String message = greeter.getGreeting(); System.out.println("Main app says: " + message); } } ===ENDFILE=== ===FILE=== Index: 3 Path: pom.xml Length: 659 Content: <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>my-simple-app</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

Prompt to request the format if starting from scratch: Present the entire codebase using the following multi-file format:

The codebase should be presented as a single, monolithic text output. Inside this output, represent each file of the project individually using the following structure:

Start Marker: Each file must begin with the exact line: ===FILE===

Metadata Block: Immediately following the start marker, include these four specific metadata lines, each on its own line:

Index: <N> (where <N> is a sequential integer index for the file, starting from 1).

Path: <path/to/file/filename.ext> (The full relative path of the file from the project's root directory, e.g., index.html, css/style.css, js/script.js, jobs.html, etc.).

Length: <L> (where <L> is the exact character count of the file's content that follows).

Content: (This literal line acts as a separator).

File Content: Immediately after the Content: line, include the entire raw content of the file. Preserve all original line breaks, indentation, and formatting exactly as it should appear in the actual file.

End Marker: Each file's section must end with the exact line: ===ENDFILE===

Ensure all necessary files for the project (HTML, CSS, JS) are included sequentially within the single output block according to this structure.

Crucially, enclose the entire multi-file output, starting from the very first ===FILE=== line down to the very last ===ENDFILE=== line, within a single Markdown fenced code block using exactly five backticks (`````) on the lines immediately before the first ===FILE=== and immediately after the last `===ENDFILE===`. This ensures that any triple backticks (```) within the generated file content are displayed correctly.

His videos also have 0 substance and now are mostly article reading, which is also forgivable if you add valuable input but that’s never the case with him.

[1] https://cloud.google.com/blog/products/ai-machine-learning/t...

For example, yesterday I wanted to make a 'simple' time format, tracking Earths orbits of the Sun, the Moons orbits of Earth and rotations of Earth from a specific given point in time (the most recent 2020 great conjunction) - without directly using any hard-coded constants other than the orbital mechanics and my atomic clock source. Where this would be in the format of `S4.7.... L52... R1293...` for sols, luns & rotations.

I keep having to remind to to go back to first principles, we want actual rotations, real day lengths etc. rather than hard-coded constants that approximate the mean over the year.

I think the "AI Premium" plan of Google One includes access to all the models, including the latest ones (at least that's what it says for me in Spain): https://one.google.com/plans