It’s not a strawman because not only is classifying unperformant code is a different task than generating performant replacement code. LLM can only generate code via it’s internal weights + input it doesn’t guarantee that that code is compilable, performant, readable, understandable, self documenting or much of anything.

Yet, nothing stops you as a developer from reading this code. Furthermore, the real value of DeepSeek R1 is that it’s explaining its reasoning for how it arrived at a solution. That itself can be useful to read through and can give you ideas on how you might want to tackle it. Here’s concrete toy example for you:

<think> Alright, so I need to write a Clojure function that prints the current time. Hmm, where do I start? I’ve heard Clojure is a functional programming language that runs on the Java Virtual Machine. Okay, so maybe I can leverage some Java libraries for this.

First, I remember that in Java, there’s a class called java.util.Date which represents dates and times. Maybe I can use that in Clojure as well. But wait, how do I call Java classes from Clojure? Oh right, you just refer to them using their fully qualified names.

So, I think I’ll need to import java.util.Date or refer to it directly in my function. Then, maybe create a Date object which represents the current time. That should give me something to work with.

But Clojure has its own way of handling dates and times too, right? There’s the clojure.java-time library that provides a more idiomatic way to handle dates in Clojure. I wonder if I should use that instead for better readability and modern features.

Assuming I decide to stick with the built-in Java Date class, how do I get the current time? Oh, there’s a method called System.currentTimeMillis() which returns the current time in milliseconds since the epoch. Maybe I can use that to create a Date object.

So, putting that together, I might write something like (new java.util.Date()). But then, how do I print this date in a human-readable format? Java has SimpleDateFormat for formatting dates. So, I’d need to import that as well.

Wait, Clojure allows me to use Java’s SimpleDateFormat directly. So, I can create a formatter and then format the Date object with it. The pattern string would determine how the date is displayed. For example, “HH:mm:ss” would give me hours, minutes, and seconds in 24-hour format.

Putting this all together into a Clojure function: I’ll define a function that creates a Date object representing now, then use SimpleDateFormat to format it, and finally print it out using println.

But what about dependencies? Do I need to add any additional libraries beyond the standard Java libraries? For java.util.Date and SimpleDateFormat, I think those are part of the standard JDK, so no extra dependencies should be needed.

Alternatively, if I choose to use clojure.java-time, which is a more modern approach, I would need to include that library in my project. But for simplicity, maybe sticking with Java’s utilities is better since they’re already available.

So, step by step:

1. Create a Date object representing the current time.
2. Create a SimpleDateFormat with the desired format string.
3. Format the Date object using the formatter.
4. Print the formatted string to the console.

I should also consider any potential issues, like thread safety with SimpleDateFormat, but since this is a simple function and not part of a highly concurrent application, I think it’s acceptable for now.

Testing the function in my mind: when I call it, it should print out the current time in HH:mm:ss format. Does that cover everything? Yes, I think so.

Wait, maybe I can also include some examples or documentation on how to use this function. That way, anyone reading the code will know what it does and how to invoke it.

So, putting it all together, here’s what I have in mind for the function: </think>

;; A Clojure function to print the current time
(defn print-current-time []
  ;; Create a Date object representing the current time
  ;; Create a SimpleDateFormat with HH:mm:ss format
  (let [current-date (java.util.Date.)
          formatter (new java.text.SimpleDateFormat "HH:mm:ss")]
    ;; Format the date and print it
    (println (.format formatter current-date))))

Example usage:

(print-current-time)

This function will output the current time in the “HH:mm:ss” format when called. You can invoke it by simply calling print-current-time in your Clojure environment.

Lastly you injected this line of reasoning when you basically said “why would I do this boring stuff as a programmer when I can get the LLM to do it”. It’s nice that there’s a tool that you can politely ask to parse your garbage and replace with other garbage that happens to use a function that’s more performant. But not only is this not Software Engineering, a dot product is a fucking solved problem at EVERY level of abstraction from bits all the way up to your favorite interpreted language.

Once again, what I actually said was that LLM can help you identify bits of code that might be interesting, and this is valuable in a large project. This is exactly the same task you’d use a profiler for.

I quite literally pointed several limitations in the post you replied to and in this post from a Software Engineering perspective.

And I quite literally explained why the tool is still useful. In particular, the argument you keep making that you would just blindly copy/paste code the LLM produces is a complete straw man. A competent engineer will read what the LLM says and use it to inform a solution they understand.