My favorite use-case for AI is writing logs

https://newsletter.vickiboykis.com/archive/my-favorite-use-case-for-ai-is-writing-logs/

by todsacerdoti • 1 year ago

259 178 1 year ago

newsletter.vickiboykis.com

Automates a tedious, time-consuming task. Easy to catch and correct failures. Love it. My only concern is (other than maybe verbosity) is of my log writing moments are opportunities to briefly reflect on what I have written, and maybe catch problems early.

specproc2• 1 year ago

Yeah, the areas AI has provided real value to me are the simple things: logging, docstrings and cli stuff being the best examples.

I can throw up a basic sketch, focusing on the code, and get it to add the quality stuff after.

interroboink• 1 year ago

The thing I like here is that it runs locally. I use Vim keyword completion[1] a lot for next-word completion. It does a broadly similar sort of "look at surrounding code to offer good suggestions" thing (no LLM stuff, of course). It's wrong often, but it's useful enough that it saves me time overall, I feel.

So, this sounds to me like an expanded version of that, more or less.

I think I'd prefer an AI future with lots of little focused models running locally like this rather than the "über models in the cloud" approach. Or at least having such options is nice.

[1] https://vim.fandom.com/wiki/Any_word_completion

There's also omni-completion, a bit more advanced: https://vim.fandom.com/wiki/Omni_completion

spiralcoaster• 1 year ago

The amount of cognitive overhead in this deceptively simple log is several levels deep: you have to first stop to type logger.info (or is it logging.info? I use both loguru and logger depending on the codebase and end up always getting the two confused.) Then, the parentheses, the f-string itself, and then the variables in brackets. Now, was it your_variable or your_variable_with_edits from five lines up? And what’s the syntax for accessing a subset of df.head again?

What you're describing is called: programming. This can't be serious. What about the cognitive overhead of writing a for loop? You have to remember what's in the array you're iterating over, how that array interacts with maybe other parts of the code base, and oh man, what about those pesky indices! Does it start at 0 or 1? I can't take it! AI save me!

BoiledCabbage• 1 year ago

What you're describing is called: programming.

Is that the part of programming that you enjoy? Remembering logger vs logging?

For me I enjoyed the technical chalenges, the design, solving customer problems all of that.

But in the end, focus on the parts you love.

okayishdefaults2• 1 year ago

This is a sign that the user hasn't taken the time to set up their tools. You should be able to type log and have it tab complete because your editor should be aware of the context you're in. You don't need a fuzzy problem solver to solve non-fuzzy problems.

andy99• 1 year ago

I like building stuff - I mean like construction, renovations. I like figuring out how I need to frame something, what order, what lengths and angles to cut. Obviously I like making something useful, but the mechanics are fun too.

morkalork• 1 year ago

I actually take pride in the logs I write because I write good ones with exactly the necessary context to efficiently isolate and solve problems. I derive a little bit of satisfaction from closing bugs faster than my colleagues who write poor logs.

noisy_boy• 1 year ago

Is that the part of programming that you enjoy? Remembering logger vs logging?

No but genuinely like writing informative logs. I have been in production support roles and boy does the lack of good logging (or barely any logs at all!) suck. I prefer print style debugging and want my colleagues on the support side to have the same level of convenience.

Not to mention the advantages of being able to search through past logs for troubleshooting and analysis.

sodapopcan• 1 year ago

Is that the part of programming that you enjoy? Remembering logger vs logging?

If you're proficient in a programming language then you don't need to remember these things, you just do it, much like spoken language.

AdieuToLogic4• 1 year ago

> What you're describing is called: programming.
Is that the part of programming that you enjoy? Remembering logger vs logging?

If a person cannot remember what to use in order to define their desired solution logic (how do I make a log statement again?), then they are unqualified to implement same.

But in the end, focus on the parts you love.

Speaking only for myself, I love working with people who understand what they are doing when they do it.

bowsamic2• 1 year ago

It's not about focussing on what you love but about basic competence and being able to deal with simple programming problems

MangoToupe2• 1 year ago

Enjoying any part of this seems a little odd to me. The enjoyable part is using the thing you built. Regardless, programming (remembering logger vs logging, syntax, debugging) is certainly the easier end of things.

endymion-light2• 1 year ago

Yeah - a lot of these complaints feel like what I heard very early in my career about how you shouldn't learn python. The C learning I did was still useful, but I appreciate not artisanally crafting all my memory management by hand so that I can ship something that i've created faster

dakiol• 1 year ago

If you remove all the tiny details that you detest because you think you should better spend your time on the “important stuff”, be careful; you may wake up one day and not care enough about anything because you have been discarding stuff bit by bit.

xdfgh1112• 1 year ago

For me it's the opposite, I know exactly how to write log lines. It's just tedious. AI auto completes pretty much what I would have written.

lmm3• 1 year ago

If it's really that tedious and mechanical, there should be a code-level affordance for it (e.g. a macro, or something like https://github.com/lancewalton/treelog). Code is read more than it's written, and code that can be autocompleted isn't worth reading.

btown• 1 year ago

One of the things I love about computing and computer science is how the wide variety of tools available, built over multiple generations, provide people with the leverage to bring their highly complex ideas to life. No matter how they work best, they can use those tools as a way to keep their mind focused on larger goals with broader context without yak shaving every hole punched in a punchcard.

You see a person whose conception of programming is different from yours; I see a person who's finding joy in the act of creating computer programs, and who will be able to bring even more of their ideas to life than they would have beforehand. That's something to celebrate, I think.

nbbaier• 1 year ago

Well said!

gopalv• 1 year ago

who will be able to bring even more of their ideas to life than they would have beforehand.

This is the core part of what's changing - the most important people around me used to be "People who know how".

We're slowly shifting to "Knowing what you want" is beating the Know-how.

People without any know-how are able to experiment because they know what they want and can keep saying "No, that's not what I want" to a system which will listen to them for without complaining supplying the know-how.

From my perspective, my decades of accumulating know-how is entirely pointless and wiped away in the last 2 years.

Adapt or fall behind, there's no way to ignore AI and hope it passes by without a ripple.

bravetraveler• 1 year ago

Calling aptitude "yak shaving" is certainly something to consider

_alternator_2• 1 year ago

Yeah, it’s also surprising because the user really shouldn’t be using f-strings for logging since they get interpolated whether or not the log level is set to INFO. This is more important when the user is writing say, debug logs that run inside hot loops, which will incur a significant performance penalty by converting lots of data to its string representation.

But sure, vibe away.

blibble• 1 year ago

yep, putting user input into the message to be interpolated is asking for trouble

in C this leads to remote code execution (%n and friends)

in java (with log4j) this previously lead to remote code execution (despite being memory safe)

why am I not surprised the slop generator suggests it

astrange2• 1 year ago

Format strings are very useful, so I'd suggest fixing the language to let you use them. You don't have to live with it interpreting them too early!

Even better, you should be interpreting them at time of reading the log, not when writing it. Makes them a lot smaller.

d0mine• 1 year ago

f""-strings for logging is an example of "practicality beats purity"

Yes, f""-strings may be evaluated unnecessarily (perhaps, t-strings could solve it). But in practice they are too convenient. Unless profiler says otherwise, it may be ok to use them in many circumstances.

2muchcoffeeman• 1 year ago

Good news. You can get AI to refactor this sort of stuff away easily.

webstrand• 1 year ago

I can totally write the logging code myself, but its tedious formatting the log messages "nicely". In my experience AI will write a nice log message and capture relevant variables automatically, unlike handwritten statements where I inevitably have to make a second pass to include a critical value I missed.

skydhash3• 1 year ago

I think we need to abandon this idea of writing code like a scribe copying a book. There’s a plethora of tools ready to help you take advantage of the facts

- that the code itself is an interlinked structure (LSPs and code navigation),

- that the syntax is simple and repetitive (snippets and generators),

- that you are using a very limited set of symbols (grep, find and replace, contextual docs, completion)

- and that files are a tools for organization (emacs and vim buffers, split layout in other editors)

Your editor should be a canvas for your thinking, not an assembly line workspace where you only type code out.

phendrenad22• 1 year ago

Yes but cognitive load is a real thing. Being free to not think about the proper format to log some generic info about the state of the program might seem like a small thing, but remember, that frees up your mind to hold other concerns. See well-trodden research that the human mind can hold roughly three to five meaningful items in working memory at once. When in the flow of programming, you probably have a complicated unconscious process of kicking things out of working memory and re-acquiring them by looking at the code in front of you. I think the author is correctly observing that they are getting the benefit of not having to evict something from their mental cache to remember how logging works for this particular project (especially egregious if you work on 10 codebases and they each use a different logger).

fleebee• 1 year ago

How often do we print debug something that isn't just a single variable? I have defined a macro in my editor that expands into a nicely formatted logger call when I type "dbg" and the variable name. I can do it without thinking or losing focus.

On the other hand, if I used an LLM to guess what I wanted to get logged (as the author did), I'd have to read and verify the LLMs output. That's cognitive overhead I normally wouldn't have.

Maybe I'm missing something, but I just don't find myself in situations where I only vaguely know what I want to debug and would benefit from an LLM guessing what that could be.

conradev• 1 year ago

The author clearly dislikes writing logging code enough to put the work into creating a fine-tuned model for the purpose.

I thought “making tools to automate work” was one of the key uses of a computer but I might be wrong

bigstrat2003• 1 year ago

One thing that has become abundantly clear from the AI craze is how many people - who do programming for a living - really don't like programming. I don't really understand why they got into the field; to be honest, it seems kind of like someone who doesn't like playing the guitar embarking on a career as a guitarist. But regardless of the reasons they seem to be pretty happy for a chance to not have to program any more.

a_bonobo• 1 year ago

Do you like 'solving problems' or do you like 'getting into the weeds'? Both are valid, and both are common uses of programming.

When I was younger, I loved 'getting into the weeds'. 'Oh, the audio broke? That gives me a great change to learn more about ALSA!'. Now that I'm older, I don't want to learn more about ALSA, I've seen enough. I'm now more in camp 'solving problems', I want the job done and the task successfully finished to a reasonable level of quality, I don't care which library or data structure was particularly used to get the job done. (both camps obviously overlap, many issues require getting into the weeds)

In this framework, the promise of AI is great for camp 'solving problems' (yes yes hallucinations etc.), but horrible for camp 'getting into the weeds'. From your framing you sound like you're from camp 'getting into the weeds', and that's fine too. But I can't say camp 'solving problems' doesn't like programming. Lot of carpenters out there who like to build things without caring what their hammer does.

simonw2• 1 year ago

One thing that has become abundantly clear from the AI craze is how many people who do programming for a living are actively hostile to fascinating new applications of computer science that open up entirely new capabilities and ways of working.

sneak• 1 year ago

I love programming, but 90% of it is crappy toil due to language or tool design. I especially hate about 90% of the stuff one has to do to work around bad design decisions when writing significant amounts of python or javascript.

Disliking toil is not the same as disliking programming.

closewith3• 1 year ago

Most software developers work in software because it's well paid and much easier to break into than other similarly paid jobs.

Most software developers never write software outside of education or employment. That's completely normal.

Even most recreational programming is to solve a problem. Very few developers write software for the pleasure of it and would happily use a magical "solve my problem" button instead.

This is also true for all employers and customers.

Honestly, it sounds to me that you fundamentally misunderstand the industry in which you work.

latexr• 1 year ago

I don't really understand why they got into the field; to be honest

Money. Startup hype. Thinking they’ll be the next Zuckerberg (as if that’d be a good thing).

viraptor5• 1 year ago

it seems kind of like someone who doesn't like playing the guitar embarking on a career as a guitarist

Do you like playing guitar or do you like putting pressure on the correct length of the string at the specific distance from the fret?

Do you like programming, or do you like manually typing out all the trivial details of each separate line? I've not found any pleasure in typing out the details of DTOs and their conversation functions repetitively by hand, for example.

paulmooreparks4• 1 year ago

I like having muscles. I hate lifting weights. I like being fit. I hate running. I like being able to play guitar and piano. I hate practicing. I like having food in my pantry. I hate grocery shopping. I like having custom software that fits my needs. I hate writing code.

therein• 1 year ago

But this is using a machine to do the lifting for you so you don't develop the muscles. You are actually not strong through technology but left weak and helpless when left on your own.

It is just a bunch of people that don't take pride in self-sufficiency. It is a muscle that has atrophied for them.

bowsamic2• 1 year ago

Do you like doing anything? Sorry but it's just straight up bad if you only like results and hate the process to get there. That is not a fulfilling life

adamhartenz• 1 year ago

You don't use auto-complete for for-loops? Wait... You use a compiled language, rather than writing machine code by hand? Some would call THAT programming.

bravesoul2• 1 year ago

Also logging is important! Send structured logs if possible. Make sure structure is consistent between logs. You may have to reach for some abstraction or metaprogramming to do this.

All logs can be message, object and no need to format anything.

That said ai saves typing time.

ghurtado• 1 year ago

What you're describing is called: programming.

And once you have enough experience, you realize that maintaining your focus and managing your cognitive workload are the key levers that affect productivity.

But, it looks like you are still caught up with iterating over arrays, so this realization might still be a few years away for you.

jychang• 1 year ago

Yeah. This is a really weird complaint to be honest.

By that standard, python is not real programming because you're not managing your own memory. Is python considered AI now?

mym19902• 1 year ago

Abstraction has always been a part of programming. Are you going to deride someone for not remembering how to write a sorting algorithm from scratch when .sort() is available? This is just another instance of that, trivial as it may be. The next abstraction level for programming is just natural language, if you want to try to gate keep that, have fun.

skydhash3• 1 year ago

Natural language to formal language is not a matter of implementation details, it’s a matter of ambiguity where the definition of a term is contextual. Formalism is removing the dependency on context so that the semantic of a term or a proposition is embedded in itself.

Formalism is so essential that we we use it to create spontaneous form of programming language (that we call pseudocode) to express some idea clearly.

chvid• 1 year ago

The section you refer to is a justification for code completion and possible providing (visual) feedback for whether a various constructs are spelled or used correctly. It is fairly established that sort of thing increases programmer productivity (as in writing a Java program using notepad vs. writing it using IntelliJ).

In the old days, we used to do this by using static type inference. This is harder to do in dynamic languages (such as Python), so now we try to do it with LLMs.

It is not obvious to me that LLMs are a better solution; you may be able to do more but you loose the predictability of the classic approach.

CafeRacer• 1 year ago

Yeah! And actually writing this inefficient code in python? Seriously? Be a man, write assembly.

Cthulhu_2• 1 year ago

What you're describing is called: programming. This can't be serious

What that statement is telling me is that the author at one point didn't consider logging to be a fully fledged formal non-functional requirement, more of an optional and/or informal side chore.

I used to work at a company that built software for mobile networks; their entire C codebase was full of logging statements, pretty much every step made in processing a signal was logged. Probably as a form of tracing, and automated instrumentation would possibly have been a better solution, but they were a bit old fashioned.

timcobb• 1 year ago

I relate to this. The cognitive overhead of a for loop is, honestly, way less for me writing a log. There's something about writing logs that's a PITA.

nojito• 1 year ago

What you're describing is called: programming.

If you feel copying and pasting documentation is programming, you’re gonna have a really rough time.

wiseowise• 1 year ago

What you’re describing is useless noise that shouldn’t even be a blip on my radar.

Programming is solving a problem, not learning 20 different ways to say Log, logger, lumber, timber, and whatever else “creative” name writer of logger library chose to use.

AmazingTurtle• 1 year ago

came here to say this. I don't want to wrap my head around writing pretty logs and involving all the variables I want to eventually see in my logs. I just want to "dump it" and keep writing main logic

theshrike795• 1 year ago

Exactly, I switch between multiple languages, projects and library conventions daily.

I can’t be arsed to remember how I add parameters in which type and did this one have context or not.

Just today I got bit (again) by the fact that the Go log library doesn’t have Debug as an option. And I’ve been writing Go for a decade. (log/slog does have levels though)

Viliam1234• 1 year ago

What about the cognitive overhead of writing a for loop? You have to remember what's in the array you're iterating over, how that array interacts with maybe other parts of the code base, and oh man, what about those pesky indices! Does it start at 0 or 1?

I am old enough to remember people complaining about having to write a semicolon at the end of each line. Or declare a variable...

cratermoon• 1 year ago

AOP solved this 30 years ago, though.

nvader• 1 year ago

I'd like to consult the HN hive mind on an tangential point.

Does anyone else here dislike loguru on appearance? I don't have a well-articulated argument for why I don't like it, but it subconsciously feels like a tool that is not sharp enough.

Was looking for evidence, either way, honestly. The author is using loguru here and I've run into it for a number of production deployments.

Anyone have experiences to share?

nxpnsv5• 1 year ago

It looks great out of the box, has fancy colors (if you want them). It is easier to configure than logging and you don't need a lot go get_logger stuff. It does log rotation, and you has lazy formatted {} comments `logger.info("x={x:.2f}", x)`. It is better for threading/multiproc, handles exceptions better. And it is fast. I like it on appearance.

alanbernstein• 1 year ago

Never heard of it before this, but it looks nice. Some tools are better ergonomic than sharp?

greatgib2• 1 year ago

Loguru sucks very badly! I would advise you not to use it. It is like trying to not do like everyone else, but still doing in a terribly wrong way ...

For example the backtrace try to be cooler for display but are awful, and totally not appropriate to pipe in monitoring systems like Sentry.

In the same way, as you can see in the article, that is the only logging library that doesn't accept the standard %-string syntax to use instead its own shitty syntax based on format.

nxpnsv5• 1 year ago

The {} syntax is better, and more similar to f-strings. And you don't have to use that backtrace. I use it to send json for some batch jobs, or have it write to google cloud logger for gcp jobs. Are you holding it wrong?

greatgib2• 1 year ago

It's totally subjective that it is better. It's not like it can "execute code" inline like f-string. Just the replacement character is the same, end of the comparison. And any way the point is that more that it totally breaks the general convention for no valid reason. It's not even optional.

For gcp jobs you can just output the structured log in the standard output so I don't see the purpose here. There are other structured logging libraries if this is what you need.

For the backtrace yes, because logging.exception will be broken by default and all tools that process the backtrace automatically like sentry. And again, for no valid reason except than "look, my traceback looks so much cooler on my screen because I added crap and new lines when printing it"...

spencer-p• 1 year ago

I appreciate how the author highlighted the python domain-specific tricks like dropping imports and rewriting tabs/spaces. It's good to be reminded that even with "large" language models you can get better results with quality over quantity.

lblume• 1 year ago

From how I read it dropping imports happens for every language.

arscan• 1 year ago

An aside, but it’s quite unfortunate that logger.info and logging.info are automatically linkified because of the .info TLD in this case. I don’t recommend clicking on those links.

Spivak• 1 year ago

Python programmers, don't use f-strings for your logs.

    # yes
    logger.info("Super log %s", var)
    # no
    logger.info(f"Super log {var}")

I know, it's not as nice looking. But the advantage is that the logging system knows that regardless of what values var takes that it's the same log. This is used by Sentry to aggregate the same logs together. Also if the variable being logged also happens to contain a %s then the f-string version will throw an exception. It doesn't matter because f-strings are so fast but the % method is also lazy and doesn't interpolate/format if it's not going to be logged. Maybe in the future we'll get to use template strings for this.

bbkane2• 1 year ago

Thanks for the reasons! I've been using f-strings because they're easy to keep track of, but you make really good arguments (I hadn't thought of Sentry/similar systems using %s to aggregate logs)

WD-422• 1 year ago

They aren't just arguments, it's facts. f-strings in logs, especially in a hot code path, can be really bad for performance.

nxpnsv5• 1 year ago

Well if you use loguru (and really you should, it is awesome) you would use, `logger.info("Super log {var}", var=var)` (possibly without the keys). It is also lazy and works better for structured logs.

suriya-ganesh2• 1 year ago

This tracks with how I've been doing my debug logs.

I ask the model to create tons of logs for a specific function and make sure there's an emoji in the beginning to make it unique (I know HN hates emojis).

Best thing of all, I can just say delete all logs with emojis and my patch is ready. Magical usage of LLMs

Disposal84332• 1 year ago

Do you use a debugger?

suriya-ganesh2• 1 year ago

I do, but logs are better.

Guid_NewGuid• 1 year ago

The use of AI for this seems somewhat overkill, one could just use a language and environment that is aware of whether `logger` or `logging` is available, and what variables are in scope. We have tools that allow us to treat programming as more than guessing the next character at random. Rather they allow you to offload tracking this context to the machine in a reliable way, typed languages and auto complete.

I do wonder if this is part of the divide in how useful one finds LLMs currently. If you're already using languages which can tell you what expressions are syntactically valid while you type rather than blowing up at runtime the idea a computer can take some of the cognitive overhead is less novel.

gbalduzzi• 1 year ago

I think we are overcomplicating this a bit.

Typing "log" and tab to accept the auto complete is faster than writing the whole log yourself.

When you need to add a bunch of log statement, this tool makes the activity faster and less tedious.

Is it a technological breakthrough? No

Does it save hours of developer time each day? No

Is it nice to have? Hell yeah

fudged71• 1 year ago

Tangential, but making the logs understandable by the LLM is also very useful

TZubiri• 1 year ago

I once wrote a simple python program that logged all execution, self inspected code and printed code and variables as output.

Then I learned why programs don't do that by default.

Not to be snarky, but when you become more experienced you will figure out that logging is just writing to permanent storage, one of the most basic blocks of programming, you don't need a dependency for that, writing to disk should be as natural as breathing air, you can do print("var",var). That's it.

If you are really anal you can force writing to a file with a print argument or just a posix open and write call. No magic, no remembering, no blogpost. Just done, and next.

whyenot• 1 year ago

My favorite use-case for AI is writing logs

You mean like this?

    [2025-07-17 18:05] Pallet #3027 stacked: Coast‐live oak, 16" splits, 0.22 cord.
    [2025-07-17 18:18] Moisture check → 14 % (prime burning condition).
    [2025-07-17 18:34] Special request tagged: “Larina—aromatic madrone, please!”
    [2025-07-17 18:59] Squirrel incident logged: one (1) cheeky Sciurus griseus absconded with wedge.

...or something more like this?

    Base-10 (log10) handy values
    --------------------------------
    x        log10(x)
    ------------------
    2        0.3010
    e        0.4343
    10       1.0000
    42       1.6232
    1000     3.0000
    1e6      6.0000

spapas82• 1 year ago

This is interesting, I like the way jetbrains is using the local models for auto completion.

Do you know if there's a similar solution for vscode?

andutu• 1 year ago

On the one hand writing logs can be tedious. Essentially logs are breadcrumbs signifying when significant state changes have logically taken place. From what I've seen, logs are added after every few lines and I always fantasized about creating a language where logging is "automatic".

On the other hand, writing logs is a skill worth mastering. Wrote too many and when a service crashes you have to shift through lots of noise and potentially miss the signal. I once went down a rabbit hole trying to root cause an issue in a Gunicorn application that had custom health check logic in it. An admin worker would read health check state from a file that worker threads wrote to. Sometimes a race condition would occur, in which an error log would be emitted. The thing was, this error wasn't fatal and was a red herring for why the service actually crashed. Of instead it would have been logged at the debug level a lot of time would have been saved.

Fine let LLMs write code but take logging seriously!!!

physicles• 1 year ago

Tab autocomplete in Cursor is surprisingly good at guessing what I want to log when I type slog.Info. I’m enjoying that time save.

I agree with K&R about debuggers: when writing services that you need to debug in prod, you live and die by your logs. That said, sometimes an interactive debugger is faster than adding logs, like when you’re not sure about the precise call stack that leads to a given point, or there’s a bunch of stuff you need to keep track of and adding logs for all of it is tedious. But pretty quickly you can hit a point where you’re wasting more time in the debugger than it would’ve taken to add those logs…

nxpnsv5• 1 year ago

It does well but also sometimes gets it completely wrong but plausible looking. Together, we managed to make several quite intricate bugs. About two months in, I actually don't think my coding speed increased much from using Cursor - and I just can't take "Perfect, ..." "You're absolutley right, ..." - even with custom rules to supress it, it just can't help itself.

Animats2• 1 year ago

Usually, people use AI for reading logs, looking for interesting events or patterns. That goes way back. Microsoft was using it to classify and group similar crash dumps back in the 1990s.

Rust lets you write a default debug print for each struct, and will generate one if asked. So you don't have to write out all the fields yourself. That's enough to do the annoying part of the job.

djmips• 1 year ago

Microsoft was using 'AI' in the 90s?

badsectoracula• 1 year ago

AI and ML aren't new, they were already well established by the 90s. For example the book from which i first learned about neural networks[0] was written in 1997.

[0] https://www.cs.cmu.edu/~tom/mlbook.html

closewith3• 1 year ago

Expert systems and decision trees were AI in the '90s.

Remember, it's only AI until it works.

neuroelectron• 1 year ago

An example of the output would be very helpful

swiftcoder2• 1 year ago

Programmer apparently never learned about "import ... as" syntax, adopts fuzzy LLM autocomplete instead. News at 11

swiftcoder2• 1 year ago

And look... I do get it. I have to switch between rust/typescript/python on the regular, and 3x sets of quirky syntax is a lot to keep in working memory.

I'd rather simplify our software stacks than accept that an autocomplete that lies to me is the only tractable solution, though

MagicMoonlight• 1 year ago

I thought this was going to be about an AI which actually writes useful logs for your program. Eg if it crashes, it explains in normal language what happened.

pandemic_region• 1 year ago

I’ve been a happy JetBrains customer for a long time now, and it’s because they ship features like this.

The Goland and Pycharm experience must be radically different from the Java experience then.

voidUpdate• 1 year ago

Visual studio added the single line autocomplete thing a while back and it lasted about 2 days before i turned it off because it was frequently wrong and just got in the way. I often use the double tab template insert feature, but that would often accept the incorrect autocomplete instead, so i had to delete it and try again

specproc2• 1 year ago

Totally agree, this behaviour is maddening. I set a hotkey to toggle completions, made it useful again.

i_niks_86• 1 year ago

Could full-line code completion and smarter log inference change how developers approach debugging and monitoring altogether? If so, how?

andrelaszlo• 1 year ago

I would have flagged that they're logging their Redis URL, if I was reviewing this. Most of the time this includes credentials.

Normally I think it's a bit rude to criticize the code of blog posts, bit I thought it was relevant here for these reasons:

"I often don’t even remove when I’m done debugging because they’re now valuable in prod" - think about where your production credentials end up. Most of the time, logging them won't hurt, just like keeping your password on a post-it doesn't hurt most of the time.

The arguments about letting an AI reduce the mental overhead is compelling, but this shows one of the (often mentioned) risks: you didn't write it so you didn't consider the implications.

Or maybe the author did consider it, and has a lot of good arguments for why logging it is perfectly safe. I often get pushback from other devs about stuff like this, for example:

- We're the only ones with access to the logs (still, no reason to store credentials in the logs)

- The Redis URL only has an IP, no credentials. (will we remember to update this log line when the settings.redis_url changes?)

- We only log warnings or higher in production (same argument as above)

Maybe I should stop worrying and learn to love AI? Human devs do the same thing, after all?

WhyNotHugo• 1 year ago

You should not use f-strings for logging, because that performs all the formatting _before_ the logging module determines if the log needs to be printed. You want the formatting overhead to happen only for logs that will get printed. You can’t achieve that with f-strings, just use normal logging calls.

It kinda speaks bad of the auto-completion that it suggests such anti-pattern.

HAMSHAMA• 1 year ago

You can do this with the new t strings! They’re like f strings, but a template instead. https://peps.python.org/pep-0750/

BiteCode_dev• 1 year ago

I have a /addlogs claude command just for that. Logging is mostly boiler plate, I'm glad I can outsource it.

mbanerjeepalmer• 1 year ago

LLM-written code is typically over-commented and under-logged. So much so that I've given up pleading with them to stop commenting and start logging. Instead I say 'Great, now that you've written the code please replace the comments with logs.'

yason• 1 year ago

People, in their excitement to play with or write cool tools to automate boring details in the programming process, often underestimate the value of boring grunt work.

While what you're doing consciously is something simple you're simultaneously also mucking about in your codebase in the "spinal cord level", or spending quality time with your creation. It's times like those when bigger/other things often click together the first time all the while you're doing something that's seemingly just grunt work.

ButOneDuck• 1 year ago

I get that writing logs can be incredibly frustrating, but most of the time people are looking at logs because either something went wrong, or they have a hunch that the program is misbehaving and they're looking for a clean sign or signal that they are on the right track. If I've spent multiple hours on someones broken piece of code, the last thing I want to be thinking is "did some non-deterministic chat-bot write this?", "are these logs even internally consistent?", "Why does this log mention code that doesn't exist?".

I get that is most devs least favorite part, but logs and errors are supposed to be unshakable, ground-truth understandings, things that point you to the light in a dark room of broken spaghetti code and misunderstandings.

Think about this from a users or a testers perspective, can you imagine the compounding frustration you would experience? To be chasing a skein of understanding through wall of text that you only mostly understand, to find out that the hunch was based on a red-herring by a dev who wasn't bothered to help you in return.

Not to mention the amount of non-bugs you are generating for yourself in the future, we already have bug bounties being swarmed by LLM-gen faux-bugs, how is anyone supposed to reason about real bugs if the logs are only tangentially related to the truth?

marcellus23• 1 year ago

"did some non-deterministic chat-bot write this?", "are these logs even internally consistent?", "Why does this log mention code that doesn't exist?".

This is the same complaint about all AI-generated code, the simple answer to which is, review the code yourself before committing. Or if it's a real project, it'll get reviewed by someone else anyway, same as any other code that could have a mistake in it.

My favorite use-case for AI is writing logs

Related Stories