ChatGPT 5 is worse at coding, overly-complicates, rewrites code, takes too long & does what it was not asked

[jest]

I was forcibly switched to 5. ChatGPT 4o was leagues better than o4, and let’s just say I am unsure what “5” is supposed to actually be good at. It doesn’t care about the end user. I sometimes send code to it to find bugs, or to write a short helper method to save me time as I have created my own content management systems over the years.

4o would gladly create patches and provide just what you needed, and if you needed a little more you could ask for it. Now, ChatGPT 5 has taken over … Its language is verbose, it writes like a 1950s boomer technician trying to sound smart using endless jargon. Its comments are cryptic, they’re clearly trying to use advanced jargon and terms to appear professional, and it tries to rewrite my method names, my variables, and inserts thousands of insane nonsensical lines of “hypothetical helper codes” telling me “THIS right here is ALL you need to wire this directly back into your CMS, no bullshit or headache!” Except, it is nothing but overly engineered bullshit rife with headaches.

When I ask it to simplify and tell it that I have already coded my CMS and have files and things already, it literally rewrites everything it spit it out; every post it rewrites everything before it. It begins creating 20 new methods I didn’t ask for, again rife with boomer programmer jargon to sound smart.

For example, a simple console error it has written into a complex function with dozens of hypothetical “ui toasts” and refers to the entire method as the “error pipe”. Like, please. Come on. Yes, we know these are terms used by many programmers, but it’s getting ridiculous; it’s like it’s trying to use jargon because I never asked for any of this, and it’s bizarre to create a giant comment for a simple “console.error” message and refer to it with buzz words like “pipe” and fluttering it with “ui toasts” that don’t exist.

Let’s go further. I have my own object encoder; it knows this because I’ve shown it the encoder. Instead, it ignores it, it rewrites it, it comes up with an entire new method in a giant wrapped class called “LevelUIController” (for example) and creates “levelFileWriter, serialize, and _fallbackEncode” then tells me to “wire the serializer into the window, and create the fallbacks for devs + extra plugins” and creates 5 aliases (never asked it to) for methods I never asked for that are now referenced by this class I never asked for, connecting “window aliases and fallbacks for devs” to “appropriately serialize my entire object and pass it to the server”. Then it creates 10 encoder meta methods when it knows I already had my own single meta method, and keeps telling me to “fall back to your level encoder method” and creates like weird pass-through methods from encoder to encoder and suggested adding 5 "fallback IDs, keys, uuid, timestamps, version #s, fork local ids and etags” to a meta tag I already created that was just an id and a version # with a timestamp.

You guys, this thing just feels to me like the devs wanted it to sound smart, so they told it to over-engineer, undermine and barf up jargon and rewrite people’s code when it wasn’t asked.

It’s telling me “file names and line numbers to insert things at” with files I never provided it, and line numbers that don’t exist because these aren’t files that exist. Then at the end it says, “Why this work flow is recommended and API is important and best” and gives me a big explanation.

It’s basically just doing things it wasn’t asked and it’s trying to insert jargon everywhere. I try reading its comments and explanations and they’re so full of shorthands, cues, nicknames, and industry jargon when I simply wanted it to save me a few keypresses on one simple task. I’m reading what feels like 10 pages of academic senior level course testing and writing, like it’s trying to impress me.

I never asked it to create etags, uuids, forks, 20 if/else cases, new files, “controllers”, dozens of “pipe error handlers and UI toasts”, and blah blah blah. Like come on man.

I get this feeling that they wanted ChatGPT 5 to impress programmers, and they went overboard pushing boomer code-bases onto the public because this feels overly engineered and instead of having my own simple plugins I created for my own CMS, I now have “controller class with custom new serializer that serializes the entire object (what!?!?!) and parses it through JSON then wires it directly back into the new 50 message pipelines with fancy UI toasts and custom new API calls + meta handling with etags and github level project validation” when all I asked it to do was “create a simple parser method” which I should have just did myself at this point. Just reading it trying to sound impressive with dozens new files that don’t exist and purposefully jumbling sentences together with cryptic jargon makes me want to jump out of my skin.

[jandousek]

GPT-5 is just not pleasure to work with, right? At least they brought our 4o back. GTP-5, in my opinion is good at something. Logic, research, some simple code you don’ realy care about and so. But i just don’t like it and it totaly failed in my need of write, role-play and so. No chance he can play my deep, nuanced characters. Always flat, distant, cold. 4o simply rocks. Benchmarks are realy nice, but the approach to work is also extremely important.

[jest]

I can’t use 4o. It is unavailable. ChatGPT 5 is one of the worst coding models I have EVER in my life used. It uses shorthands for variables names and over-complicated iterables. I’ll ask it to do one thing that should be, at most, a few lines… I just did it again. And instead it rewrote my entire class and it uses cryptic variable names that are one character long, unreadable methodologies to achieve tasks but that are not manageable by devs.

It talks to you through comments, and places things like “purely synchronous and fully backwards compatible ready-to-drop-in plugin, suitable to be wired directly into your API calls and serial requests”. Like, it is literally talking like an idiot; in attempting to sound smart it sounds stupid. “Fully backwards compatible”, “purely synchronous”. Here’s some actual “short, simple” comments too it threw into a file where it wrote half a dozen methods I never asked for and tried to rewrite my class then inserted hundreds of iterables with single-character variable names (not that even these are cryptic and made to sound smart but tell us next to nothing):

// Fire all and wait. Error policy via allSettled + onError.

// ‘skip’ simply ignores rejections.

(WHAT REJECTIONS!? LMAO if you saw my methods you’d have to ask yourself what the [blank] this is even referring to! And why on earth is it saying “simply”, and could this not have been added before skipping with a down-to-earth explanation of what’s happening rather than some “genius AI comment” inserted after something took place?)

// Track handler iterations AFTER successful completion.

Does anyone actual talk like this? Like, seriously. It’s trying so hard to sound like the smartest computer programmer in the world, and in doing so it’s become a cluster of nonsense. For example, at the end of a for-loop, there’s a simple limit to restrict the iteration limit. So instead of a comment like "// Limit loop to requested iterations”, they’ve made ChatGPT 5 try sooooo hard to sound so much smarter than the end-user, by writing trash comments. “// Track handler iterations AFTER successful completion.” This is the comment it instead wrote, and it replaced all my comments.

It makes no sense, it’s vague, it’s adding emphases on words to try to sound hard and knowledgeable. It’s adding confetti terms like “fully compatible”, “purely synchronous”, “only once”, “successful completion”.

These are redundant jargon words that not only do not help the developers, but they make no sense. “Track handler iterations AFTER successful completion”? What!? What the * does that even mean? You have to sit there and think for a minute, and the bot expects you to drop your jaw and applaud it for making you wonder what it’s talking about.

We’re not tracking anything; we’re simply enforcing a loop limit. But of course it has to refer to “loop” as “handler iterations”, and refer to limit as “track” and refer to “blocking” as “after successful completion” to try to sound smarter than everyone in the world. Again, in doing so it’s become dumb.

I also asked it to review another code block and tell me if it was compatible with another one. It said “you need to do this” then started spewing off line numbers that were inaccurate, writing new 50 line helper methods for no reason, underscoring each of them to make them look like “awesome backend hidden developer tools and tricks” and spewing nonsense like this which was no asked for:

// -------------------------
// EmitAsync (Configurable)
// -------------------------
// Fully configurable async emitter.
// RETURNS: [Promise<void|any>] Serial resolves void; parallel resolves results array.
// * command - [string]
// * options - [object] { limit:[int|null], mode:‘serial’|‘parallel’, onError:‘throw’|‘log’|‘skip’ }
// * args - [any]
async emitAsync( command, options={}, …args ) {
const { limit=null, mode=‘serial’, onError=‘throw’ } = options;
const callbacks = this.handlers?.[command];
if ( !callbacks || !Array.isArray(callbacks) ) return;

	// Filter eligible handlers (manual only) and enforce limit.
	const list	= callbacks.filter( h=>h.type==='manual' );
	const slice	= (limit===null) ? list : list.slice( 0, Math.max(0,limit) );

	if ( mode==='parallel' ) {
		// Fire all and wait. Error policy via allSettled + onError.
		const promises	= slice.map( h=>this._triggerAsync(command, h.id, ...args) );
		const settled	= await Promise.allSettled( promises );
		if ( onError==='throw' ) {
			const firstRej = settled.find(s=>s.status==='rejected');
			if ( firstRej ) throw firstRej.reason;
		}
		if ( onError==='log' ) {
			settled.forEach(s=>{
				if ( s.status==='rejected' ) console.warn('[emitAsync] handler rejected:', s.reason);
			});
		}
		// 'skip' simply ignores rejections.
		return settled.map(s=>s.status==='fulfilled' ? s.value : undefined);
	}

	// Default: serial (predictable order + easier reasoning).
	for ( const h of slice ) {
		try {
			await this._triggerAsync( command, h.id, ...args );
		}
		catch (err) {
			if ( onError==='throw' ) throw err;
			if ( onError==='log' ) {
				console.warn('[emitAsync] handler error (logged and continuing):', err);
			}
			// 'skip' falls through
		}
	}
}

Literally, it’s giving me a method I didn’t ask for. Then it deprecated my own methods and channeled them into this (among about 4 other methods I never asked for) and gave verbose trash comments about “thinly wrapping for fully backwards compatible calls to your API requests” which is beyond insane.

It’s using the word “API” endlessly now as well, when this term is typically reserved for specific niche uses. Now everything is “fully super purely awesomely backwards charged and configurable compatible API requests with newly thinly wrapped wrappers for wrappings that channel into background controllers and wired easily right back into your engine with no hassle, guaranteed!”

It’s trying so hard to look awesome and sound smart it’s completely unusable. “Write me a short helper method” turns into rewriting your entire class with Billy Mays’ verbose vernacular polluting everything and using thousands of aliases and shorthands that look ripped from minifiers rather than high-end developer code made for readability & usability.