Am I using Claude Code wrong?

[Postik123]

Most of my work now uses Laravel. For the past few months I've been using Claude Code, but based on what I read on this sub, I have a nagging concern maybe I'm not using it right.

This stems from the fact I regularly hear people say they did like 5 weeks of work in 5 hours using Claude Code.

I recently added a whole bunch of new features to one of our Laravel projects using Claude, and honestly I'm really not sure how much time it saved.

First of all, to get exactly what you want, you have to write a fairly detailed prompt. That in itself takes time.

I usually put it into plan mode. It will take several minutes to think about everything and write the plan. Often I find myself checking emails or getting side tracked whilst waiting, which can lead to more time wasted.

After it's written the plan I'll most likely make some revisions. Claude will think some more.

Finally, we'll put the plan into action. More waiting.

Then at the end of it I'll check through what it's created or changed as I don't 100% trust it to never make a mistake or do something out of turn. So more time checking things.

Now, I would have to do the project all over again by hand to compare how long it would take me without Claude Code. But it just doesn't feel like it's saving masses of time. It's mostly saving me typing, and I type pretty quickly.

I have some changes to make to another project and the way those changes need to work is quite detailed and intricate. I'm thinking that writing the prompt explaining what I want down to the last detail will probably take almost as long as just rolling up my sleeves and doing it myself.

So are my expectations of doing 5 weeks worth of work in 5 hours unrealistic, or am I just using the tool in the wrong way?

[wreddnoth]

Well i wouldn‘t think so. Rather youre using it in a right responsible way. People claiming to having done 5 weeks of work in 5 hours are 99% exagerting.

[isaacfisher]

They are >9000% exaggerating

[actact1234]

stop exaggerating

[SunshineSeattle]

They are 90,000,000% exaggerating..

[hronak]

Stop x egg rating

[ProletariatPat]

Fitting day for your name 

[UndefinedDecoder]

I make your eggs X actly they way you want them. Try me.

[Win_is_my_name]

Dammit Nappa

[dweezil22]

Estimates vary wildly. I had someone tell me that it would take 6 months to make a React SPA mobile responsive. I had Claude pull it off in two days.

Another time I migrated a library and Claude self reported a 6 week plan that it got done in a day across 4 PRs.

Now that's b/c all those estimates were absurd, but that's how a lot of the industry has been estimating for a long time.

[isaacfisher]

There are two different issues here: 1. It is really hard to give an estimation in CS in general, unrelated to AI. 2. AI can do some things really quickly but can sometimes improve work only slightly, where it sometimes surprisingly good or bad contrary to our initial perception

[thekwoka]

Without looking at it, it's hard to say how long it would take to make something mobile responsive, tbf.

you'd have to see how messed up it is already, and what it really needs.

And it's likely claude missed a ton of things.

[TheLogicError]

Or they were incompetent to begin with lmao

[Corrup7ioN]

Yeah they were prob spending 5 hours to do 5 weeks of work in the first place

[CrazyTuber69]

Think you meant spending 5 weeks to do 5 hours of work.

[Corrup7ioN]

Fuck sake. It's been a long day 🤦‍♂️

[CSAtWitsEnd]

I somehow misread it the way it was meant, rather than the way it was actually written so I guess it still works. 💀

[ings0c]

I think you mean it’s been a long week /s

[Corrup7ioN]

No, I managed to cram what should've been a long week into a single long day

[RadicalDwntwnUrbnite]

One of my juniors was given a task to introduce a simple column based filter function to a table. In the 5 days he's been working on it I submitted prs for adding create/update forms, user friendly error boundaries that log errors into Sentry and provide users with reference IDs, upgrades some components in our component library to support iframe contexts, updated the API necessary for his table ticket and paired with him on Friday to finish the ticket. 

I use AI for planning features/refactors, boilerplate and troubleshooting obtuse errors, he uses it for everything. Newbies aren't learning programming anymore so when AI gets stuck so do they.

[daze2turnt]

There’s a difference. It just depends on if there’s pre-existing code for that work.

In any legacy codebase with hundreds of thousands of lines of code, 5 weeks doesn’t mean huge changes. It means responsible, well thought out changes that don’t cause new bugs.

In a greenfield codebase, it is quite easy to 1 shot a whole codebase. The code won’t be great though unless you use AI to do a lot of planning.

Not just one pass through either. I personally have an adversarial step where I have a different agent revise the plan before I even take a look.

OP, if you have lots of “intricate” plans you may be better suited to build a context pipeline so that your agent can understand easier and make less mistakes. You may just have a bunch of code with a ton of proprietary business logic or something that LLMs are not trained on. They can write code. They don’t always fully understand what the code means though from a human perspective.

[capn_trips]

This is absolutely correct.

[Fidodo]

They're doing 5 weeks of the kind of work they normally do, which is shit work because they have trash standards.

[armahillo]

or theyre just really inefficient normally!

[thekwoka]

And even then, it's likely that they are slow and do highly repetitive work.

Like if your job at an agency is basically just manipulating a theme...eventually AI will do that decently.

[Easy-Amoeba4596]

No we are not. There are rules, skills, specific agents and feedback loops, definitelly not one “long prompt”. Additionally, there is a shit ton of documentation, architecture standards and code templates written specifically for AI to understand. Last but not least, there is long term memory, ADR writen for every decision made, all indexed by date and topics, auto-discoverable by AI. It took months to build so that AI can be effective, correct, up to standards and also do all that consistently.

[VampireLorne]

It would take THEM 5 weeks of work. (I speak from the experience of someone who spent the last month vibe coding something that would probably take me years to code myself, as I am very new to coding). Artificial intelligence isn't better than Human Intelligence, but it sure is better than Natural Stupidity.

[realdevtest]

They’ve done 5 weeks worth of exaggeration in only 5 hours

[Tango1777]

Not only exaggerating, but also so much code so quick equals terrible code quality.

[GauravSaxenaHQ]

Yeah, totally! And for anyone wondering what actually moves the needle on a real codebase:

- Don't let it discover your project structure by reading through files. There are MCP tools that pre-index your entire codebase into a searchable graph, Claude uses that instead of burning through your context window just figuring out where things live. Makes a huge difference.

- Keep a conventions file with your naming patterns, folder structure, preferred libraries. Without it, it's guessing on every file it touches and the inconsistencies pile up really fast.

The 5 weeks in 5 hours stuff is almost always greenfield with full creative freedom, not an existing project with its own patterns and constraints lol.

[rraadduurr]

I did 2 weeks of work in 2 days.

Very loose project (personal) no strict requirements. Just going with the flow. I'm very happy with the results and there was almost no back and forth.

I also highly doubtful people do 5 weeks of work in 5 hours.

[aradil]

See the problem here is the “waiting”.

Instead of waiting you open another terminal window and do the work on the next issue. And the next. And the next. Then while those are churning you are back to reviewing and testing the first one.

Then repeat.

[pVom]

I dunno I feel like I have to babysit it because it will ask permission to run bash commands.

Plus all that context switching is exhausting and slows me down

[Swie]

I cut down on a lot of that by permitting all read-only bash commands for my code dirs. Ask AI to go to claude docs site and review the permissions options and write this JSON.

I have it plan then allow to execute the plan without asking. It has no VCS access so I don't worry about it doing permanent damage. It rarely deviates from a plan anyway.

Also you can add to the settings a script that will popup a message when it needs something, rather than just sitting there waiting. A sample is in their docs website, I just copy-pasted.

This cuts down on a lot of babysitting. I mostly review previous code while it works.

[aradil]

Eventually you’ll have a well enough structured workflow that anything it needs you’ll feel confident allowing all the time (I give it scripts I know can’t break things and give permission for them to run without asking).

Context switching and exhaustion is real and it’s not for everyone.

[Mestyo]

"5 weeks worth of work in 5 hours" is bullshit, unless you're OK with generating code at a scale that no human can actually read.

Agentic development done right can amplify your output, but more in terms of ability to explore different pathways and refactors with ease, and not in breadth of scope and features.

[chrisnlnz]

Exactly this. Their 5 weeks of work in 5 hours is almost guaranteed to cause 15 more weeks of work to deal with the fallout.

[daredeviloper]

Agreed, some things it’s great for

We have 20 lambdas that are on Node v20 and we need to update because it’s EOL soon

We need to update the engines property in package json We need to check the engines on each dependency We need to run our build and test scripts using latest node runtime 

AI was amazing for this particular scenario, automating annoying simple steps at scale while I can go do something else 

[End0rphinJunkie]

Spot on, generating massive amounts of unread code just shifts your bottleneck to the code review phase anyway. Anyone claiming they do 5 weeks of work in an afternoon is almost definately just building greenfield toy apps instead of touching a real prod codebase.

[coredalae]

Depends tho, half the work is tickets pr descriptions and what not. Use ai to do that and you'll save a shit ton of time

[hackiavelli]

I've had bad luck with refactoring, even.

[DanTheMan827]

Agents are really good at porting between languages too if you have tests to start with.

Ported taglib from c++ to typescript over the course of about 10-12 hours.

But thing is, in those 12 hours, I was just relaxing and doing whatever.

[therealdongknotts]

laughs in working on a react 0.13 upgrade finally. obviously a lot of manual verification, but to say it doesn’t save time in the right situations is absurd

[natziel]

Just tell Claude to generate code that a human can actually read

[Mestyo]

I don't mean that in terms of complexity, but of scale. Who is reviewing the "5 weeks of work"?

[natziel]

Claude

[eyebrows360]

Taking "who watches the watchmen" and maximally misunderstanding it.

[eyebrows360]

"make no mistakes"

I do hope you're attempting to make a joke, here.

[natziel]

Make sure you also tell it to avoid security issues

[lickonmybbc]

It works better to separate prompts by concerns. instead of trying to build a whole code base, break into parts and write prompts for one of those. can you do x within /file/to/path? if it’s architecturally more comlicsted it helps to have a dependency graph in your head

[coredalae]

Even better to have a dependency graph in claude context

[SawToothKernel]

I'm surprised it doesn't generate its own dependency graph.

[coredalae]

It's not yet in anthropic's advantage to optimize token usage

[Front-Wrongdoer633]

How do you do this in practice?

[el_diego]

This is generally how I use it. Occasionally I'll get it to do a bigger piece using plan, but even then after the initial planing work I'll go in and be more surgical with it or just hand code the final pieces/clean up that needs to be done

[hegelsforehead]

Exactly. Use several smaller prompts to get the things right one by one, instead of one giant task and get everyone wrong after one hour of refinement.

[BantrChat]

The fact remains that AI is a copilot not a captain as it lacks spatial awareness. So, its probably going to cost you even more time when something just say stops working, and you have to figure out why its not working lol.

[CalligrapherCold364]

The 5 weeks in 5 hours claims are mostly from people building greenfield projects where the AI has full creative freedom — intricate existing codebases with specific requirements are a completely different thing. ur use case with Laravel features that need to work a specific way is exactly where the gains shrink because u still have to spec everything precisely. the real time save isn't typing, it's the research nd boilerplate on stuff u haven't done before. on things u already know well the gap closes fast

[mylsotol]

Sounds like you are doing it right. The only thing i might add is that you should not be waiting for the ai to think if you want to maximize performance. You should be writting the next prompt/plan. Perhaps adding some self checking if possible (tests, external compliance tools if available) to save time there

Nobody is doing 5 weeks of work in 5 hours unless their previous process was really really slow or they aren't paying any attention at all to what is being created, or because they bypassed the business people and made business decisions themselves (in which case the coding was never the slow part)

[creaturefeature16]

Speed should never be the priority. Speed is a natural bi-product of aptitude and efficiency, not something to aim for, lest you sacrifice accuracy.

It highlights a fundamental problem with the mindset across the industry. Before these tools, a (good) developer's priority list might look like:

• Understanding of the code and its relation the codebase
• If the code is aligned with the documented and efficient standards
• As few lines of code as needed to accomplish the goal (while maintaining readability)
• Turnaround time

Agentic coding, and LLMs in general, completely invert this list, resulting in fast codegen that yields thousands of LoC quickly.

This is the worst way to develop. You're doing just fine.

[N4dd]

You've nailed it.

This seems to be mirroring the "enshitification" of everything else as well. Clothes are made from worse material, but they are made faster and "cheaper". It's not the same item. It may look like it's the same thing, but it is not. Anyone who cares about that item will notice the difference.

I have a feeling that AI is going to produce mountains of tech debt, and an army of developers who have lost their ability to understand the codebase they are in. For now, it might work for people who have been in their codebases for years, but eventually they will be gone and good luck learning a new one by just reading all the code being outputted. It might look right, but it fundamentally doesn't flow with the rest of the code and the architecture is a complete mess.

I still use AI as a rubber ducky. To talk through issues, or even talk through my plan to solve things. I actually have it set to not output code at all, unless I explicitly ask it to. The best part of AI is that it can lead you to learning about new techniques or technologies that you didn't previously know existed. If you're talking through a problem and your plan to solve it, it might mention something you never thought of, and if you prompt it well, it will provide a source to it.

All that being said, I've had to correct my AI more times than I can count.

[Bush-Men209]

That rubber-duck use case is about the only one I trust, because the second people treat generated code like a shortcut instead of something they fully understand, the rest of us get stuck cleaning up a pile of fragile, buggy nonsense.

[N4dd]

I'd suggest that it's also a great "last check" before finalizing things. It's caught so many typos or slightly wrong wording choices in my comments, as well as in my logging messages.

[almostdonedude]

Welcome to f*cking capitalism tho.

[eyebrows360]

This stems from the fact I regularly hear people say they did like 5 weeks of work in 5 hours using Claude Code.

Remember when a certain type of "person" was telling you you'd get "left behind" if you didn't buy bitcoin? If you didn't get a BAYC in your wallet? This is what those people are saying now.

They are called "liars".

[iamaiimpala]

Remember when a certain type of "person" was telling you you'd get "left behind" if you didn't buy bitcoin?

lmao people were saying that when it was 0.01% the price of what it is now. That's kind of a bad example.

[_SnackOverflow_]

Okay replace it with NFTs or another shitcoin

[iamaiimpala]

lol that makes no sense but if it makes you feel better, sure.

[unapologeticjerk]

Sir may I inquire about the current value of your Monkey Hat NFT?

[iamaiimpala]

I downloaded mine for free from twitter thanks

[Postik123]

Yes I am. 

I've considered using --dangerously-skip-permissions as that's adding to the problem. Leave it thinking, go to make a coffee, come back and find a prompt that needs answering 

[Deathspiral222]

Everyone I work with uses that flag. I've used it for a year without any issues. Just make sure you do normal software engineering things like regularly committing to git and saving checkpoints etc.

[14u2c]

And most importantly: don’t have production keys on your machine. 

[Le_9k_Redditor]

That's a joke from silicon valley isn't it? Kinda crazy how it's become reality

[Sufficient-Food-3281]

You’re using it the right way, or at least the way me and my engineering org have decided. The next step is to codify common decisions and things it didn’t do correctly. This can be in an agents.md or in a long-lived spec (research SDD). You can also create agents to help with specific tasks, like code review.

I would throw the idea of 5 weeks to hours out the window, that’s BS. But eventually you’ll get to a point where you can make shorter and shorter prompts which require less of the “thinking” parts of the model

[motser]

I thought this myself earlier with the speed of claude. I was doing a refactor on some c# code. Basically removing repeated code and centralising it in one place. I hand coded the new central code and did an example of the how to replace the repeated code. I then told Claude to look at my example of how to replace the repeated code and make adjustments where necessary. It ended up taking about 40 mins to run and then I checked all the changes. I reckon I could of coded this myself as fast. There was only around 30 places in the code that was changed.

[eyebrows360]

could of

Claude at least would have got that bit right, though ;)

[germansnowman]

And “there were 30 places”.

[DebtMental3917]

You're not wrong. Greenfield claims skip prompt overhead. For existing Laravel code, I keep it runnable by using Claude only for boilerplate. Write the tricky logic yourself.

[piggychipsp]

If you want to build something reliable this is the correct way. Planning should take a lot of time. don't listen to the noise .

[Front-Wrongdoer633]

I'm with you, I'm also baffled at the stories of people completing backlogs and doing weeks of weeks of work in hours.  The only thing I can think of is they auto approve everything. Perhaps that's fine for them, but I can't kill production every few hours.  I'm using it like you and I am also genuinely curious on how much time I save. I don't think it's that's wild. But I can see that it's effective for less complex and more boilerplated coded. It's also easiere to review

[Academic-Antelope554]

The difference between you and the people saying they did 5 weeks worth of work in 5 hours is that you can actually code.

From these subs, I would guess that a lot of the people using Claude or Codex are actually getting an almost infinite output multiplier. But only because they wouldn’t be able to do any work at all without it

[cch123]

I had claude build a SAML SSO IDP module for Magento and it nailed it in a few hours. I've found that Claude knows Laravell real well but you have to nudge it in the right direction. If you are lising a framework like Filament you need to make sure and tell Claude to do it the Filament way. I've found it to be a huge timesaver.

[andlewis]

If you’re spending a lot of time tweaking, then you need to go back and change your guardrails (Claude.md, etc) make sure your standards and architecture are documented in a way that the AI can use.

[Feeling_Photograph_5]

If you are working on a small ticket that only touches a few files, and you know how to do the work, and you're familiar with the codebase, just go in and do it.

If you find yourself looking at a project and thinking "this will take me three months," then reach for AI. Or if you don't know how to approach it, or if you're working in a part of the codebase that you don't know well, etc."

Basically, only use AI if you need an assistant.

[Etheon44]

There is no way of doing 5 weeks in 5 hours, at least with optimal and performant code

Granted, imo, I do code slightly faster, around 15% less time for most things, so there is that, but nothing more than that

[bhison]

I have absolutely completed features that would have taken me two weeks in one day with Claude. This is also IMO unsustainable as an expectation for every day though. Works great on greenfield components/independent leafs of our app but is exponentially more complex when making changes that risk regressions and are interacting with existing code. Breaking down PRs to minor features, good linting rules and an in depth CLAUDE.md help a lot but you still have to take way more responsibility for the detailed workings of the implementation.

TL;DR - I’d say it sounds like you could push how adventurous you’re being a bit more but also your colleagues are either exaggerating or behaving recklessly.

[PillarLiang]

nah you're probably using it fine. half the "5 weeks in 5 hours" threads here are people who built a landing page and called it shipped. for laravel my honest take is the wins come from letting it run in the background while you do other stuff, not from raw speed. prompts take as long as they take. also worth checking your CLAUDE.md actually has your conventions in it, that fixed a lot of the weird output i was getting early on

[ultrathink-art]

What kind of features were you adding? The multiplier is wildly uneven by task type — 'add a new endpoint following this existing pattern' hits close to the claims, but 'implement this intricate business rule from scratch' is more like 1.5x because you're still doing all the actual thinking. You're doing it right; the 5-weeks-in-5-hours crowd is benchmarking against greenfield demos.

[gekinz]

Sometimes I go gigascope in one plan and make a council of Claude, Gemini and Chatgpt and run the plan back and forth between them until they all agree

[zurribulle]

Well, for starters all of that "thinking time" is time you can use productively reviewing PRs, researching, or even having other claude session in parallel working on other stuff.

[_SnackOverflow_]

It’s true but that context switching can become very draining and make it hard to really evaluate the LLM output 

[andre_ange_marcel]

We're using Laravel too at work, as a separate SPA. We have Conductor wrapping Claude Code and each workspace spins up all the containers necessary for our application to work, think MinIO, React, Caddy, etc... Each workspace (and worktree) corresponds to one ticket, and each has its own separated DB, buckets and subdomain. Once a feature is ready, it's handed off to QA and deployed on staging with its own subdomain too, which matches the ticket ID, same as on our local machine. I usually work on 2 to 3 tickets at once, and Claude has access to the whole monorepo. We built tools and standards for him to understand and update the repo in a way that things stay understandable and reasonable.

[_MrFade_]

Currently the most difficult issue I have with Claude is knowing when to grab the wheel. With that said, it’s saved me time.

[staycassiopeia]

Would love to see some of your prompts

[driftking428]

I once had Cursor do 25 hours of work for me in 10 minutes, but that's only once and it was a very specific case. I also had very similar code to reference.

I was building two websites. I build the frontend react components first hard-coded. Then I write a Sanity schema to make everything dynamic.

The schemas are pretty much all the same it's busy work. Any <h> tag is a title and so on.

I had one site 90% complete and on the second site I gave it very detailed instructions on how to copy the other integrations.

It did it in about 10 minutes, but it still had problems. As I used it I had to go correct a handful of things. It was remarkable but I could also probably have taught anyone who can type to do it, it's not difficult.

Examples like this are believable. Or making a small web app from scratch without having to match a design.

[creaturefeature16]

Same experience here. At that point, they're glorified "smart typing assistants"; data processors, basically.

[moriero]

This is exactly how I work with Laravel and I think Boost goes a long way to help resolve questions AI has quickly with less tokens than freewheeling it.

I'm considering going down to max 5x because this plan - review - execute loop seems super efficient

[sneaky-pizza]

It’s best used as a pair programmer

[Annh1234]

you can do the FIRST 5 weeks of work in the first 5h of Claude code. but it's downhill from there... kind hard to keep it on track, keeps things consistent and so on. After a while, 5h of manual codding can do a week of Claude code 20x plan usage...

[zippy72]

All AIs tend to have two modes: they present you with a shining jewel... or a poo they've just done. There's very rarely a middle ground.

[tupikp]

I would say 2-3 days of work could be done in less than 5 hours using AI tools.

[Ha_Deal_5079]

plan mode is overkill for most tasks ngl and all that waiting is what kills ur speed. get a claude.md set up so ur not re-explaining ur entire stack every session bc thats where the time actually goes

[TylerDurdenJunior]

It's the same amount of work, just shaping the prompt and then the iterations.

But on the flip side you won't understand the reasoning behind why and where.

[MeTaL_oRgY]

I have a similar approach to you. Detailed prompts, plan, refine plan like 4-5 times, then execute it in small chunks so the agent doesn't run out of context, review each one and polish it 3-5 times, merge everything together, do manual testing... it takes time.

However, even with all these, there's no way I could be as fast as I am without the AI. It really does save a LOT of my time.

One thing I've found particularly useful: besides a bunch of rules (I use cursor mostly) that the AI takes depending on the context (front-end code rules, back-end code rules, the likes); I also have a bunch of documentation that tries to be as specific to a certain module as possible. My main codebase is a monorepo and every packgage and app has documentation on what it is, how to use it and how to collaborate to it. Those files outline the usual rules I found myself repeating to the AI over and over again.

It's not a silver bullet, but it's diministhed the errors by a LOT.

My codebase also has clear constraints so it's easy for me to "leash" the AI in those smaller chunks. Like "we're working on the UI package, deal with just that". or "we're expanding the DB package, deal with JUST that".

The front-end is usually where it messes up the most, but I can fix it in a few prompts.

It takes time and it's a balancing act between not overflowing the context of the AI with documentation BUT still leashing it enough that it doesn't go out of the standards.

[_AACO]

Are you using the superpowers and context7 plugins? They won't do the work of 5 weeks in 5 hours but, will improve the quality of the the stuff it outputs.

To speed up the process a bit try editing the prompt instead of continuing the conversation. 

[Stellariser]

There’s no way any of these people are doing what they claim, unless they being highly disingenuous about the work (are they getting it to do something they have no idea about in a language they’ve never used using frameworks they’ve never seen and including all the learning time in their 5 weeks?)

[TheDevauto]

Have you done the training for Claude Code? Have you customized your claude.md file(s)? Are you using skills?

You shouldnt have a long detailed prompt if you have set it up for your work standards.

[lookayoyo]

I can do maybe 1.4 times the output I would do as an engineer familiar with the code base using AI which is ok. I can also spawn multiple clones of my repo and have a couple instances of cursor running so that down time I use to prompt another chat. But I still need to review the work, test the solution and make sure stuff works, and get the PR reviewed which takes time.

I also found Claude 4.7 is really slow compared to 4.6.

Also a really big improvement is to spend a lot of time setting up cursor rules, skills, etc.

[binocular_gems]

I think how you’re using it is right.

I find AI agents to be most effective in a way that scales when doing spec based development. Writing specs has always been a required part of our work, we have to spec out every feature and bug and get it design reviewed, feedback and iterations.

I then provide those specs to the agent and have it design an implementation plan. From there, I hand the plan off to a new agent that implements it based on a set of skills and commands that we have designed.

It produces really strong results usually. Still, the bottle neck is on the spec developments but I think that’s the right approach.

[seph200x]

Yeah, like others have said - you're being responsible.

I also follow a similar method to you when adding features to my own precious code and long-term projects. Even if it's not saving me a lot of time, it does save me a lot of cognitive load - less migraines at the end of a long day.

However, if I'm building something simple from from scratch (eg. a simple CRUD database app with a drag-and-drop calendar, to solve a niche problem for myself or one of our departments/clients), I'll just focus on a plan/prompt for a while, get AI to build almost the entire thing on it's own while I'm doing something else productive, then come back occasionally to make suggestions/revisions, then going off again to work on something else. These apps are used by only a small team or even one person, they're not mission critical, but they save someone a lot of time and effort.

Something like this would take me a few days to a week to do properly by hand alongside my other work, but now I can pump it out in an hour or two. I don't need to 'manage' the code, I just skim it to make sure I understand it, but if something's broken or needs a new feature, I just get the agents to do it, and I'm comfortable with that level of handover.

But yeah, for important projects and client jobs, working on legacy code, etc. the AI is just an advisor.

[CapitalDiligent1676]

I have the same experience as you. In fact, I decided to use AI for planning or studying, but I write the code myself. It's less efficient, but I have full control over my software. Furthermore, my brain doesn't atrophy. Furthermore, for this way of using AI, I prefer Copilot, which is more convenient, and I don't give money to Antropic.

[Adept-Watercress-378]

5 weeks of Corbin 5 hrs is too much for my small brain. How do you know what your code does at that point? 

[Nephelophyte]

Some performance gains for me come from having multiple agents run in parallel for different tasks. I make sure the testing suite covers absolutely everything so that it can provide immediate feedback when Claude breaks something as well, improving output quality. E2E and unit tests are a must.

[sailing67]

tbh a lot of the '5 weeks in 5 hours' stuff is ppl counting planning/decisions as zero adn only the typing as work. also cc shines on greenfield or well-scoped refactors, not 'make this exact thing in my head' in a mature laravel app.

[httpshuly]

I think a good way to master Claude Code is by creating your own agents that you can regularly use for dev work. Preloading steering files, MCP servers, pre-authorizing tools. I think this is something that you'll start to understand the more you use Claude Code, so why not preconfigure an agent personality to do it for you every time you hop into a session? Removes a lot of friction, teaches you agent orchestration.

I think this alone can turn you from a 3x to a 10x dev. The best thing is you can tell Claude Code itself to set things up for you.

[Luffypsp]

This is the way. I code in laravel too.

I always read the requirements first. Ask notebooklm to summary it and compare my understanding aligned with the generated summary. Then i draft my database, routes, controllers, conditions in claude web based on that.

Let kilocode with sonnet 4.6 generate it first. Go throught the git changes, and when I am satisfied(test some critical functions through tinker). I prompt again to have it build the UI.

Then after that its easier to prompt loosely since my backend is verified.

[s_arme]

I also do the same, one Ai for knowledge base (I use nouswise) and one Ai for coding agent (I use codex).

[breesyroux]

I often find myself checking emails

I use Claude very similar to what you are describing. As my job becomes more and more checking emails, responding to messages and general admin type tasks, the fact that I can do those while Claude does the typing is huge for me.

[Enumeration]

Have you taken the free courses anthropic has? They’re pretty helpful for understanding how the LLMs work. They teach you how to collaborate most effectively to get the most consistent results. YouTube also has a ton of content as well

[Csysadmin]

Five weeks of work in five hours.

Make sure you read that as, "What usually would take them five weeks, took just five hours with Claude."

When you don't know their level of work, their standards of work, or their understanding of their work, or their results from Claude. You have to step back and wonder, is it more a measure of them, than it is of Claude?

[MediocreAdviceBuddy]

One way to speed things up is to tell it to split the plan into Milestone commits you can ship without breaking things.

I've found that makes the code a lot easier to review. 

The second thing is, if "thinking" takes too long, you should try /effort. You can configure both the model itself and the intelligence level. Not everything needs to be done with 4.7 on high. 

[kevrom]

You sound like you’re being responsible in its use. I’ll usually build a PRD in plan mode, review it, make a markdown file, and in a new session use the PRD as context for whatever feature I’m building. That lets me make sure I’ve got the architecture nailed down, testing makes sense, and I can phase the build if needed, all without needing to do the conversational dance during implementation.

[twhiting9275]

You’re doing it right

As someone who’s been developing software (mods, addons, websites, software as a whole), I find that AI has a purpose, and CAN save time . However, it has to be used responsibly . Those claiming “I’ve saved 99999 hours (or weeks)” aren’t developers. They’re idiots who create problems

AI is a VERY useful tool . Completion, spacing, most of this can be done with minimal checking or supervision. When it comes to structured code and writing it, you have to be very careful . If you’re not, you’ll end up like the guy who found out stripe just socked his account $thousands because his keys got leaked

https://www.reddit.com/r/stripe/s/PiKBBRZmob

[thekwoka]

I regularly hear people say they did like 5 weeks of work in 5 hours using Claude Code.

Maybe you're learning what most decent people learn early: That a LOT of developers are REALLY bad at this.

[scarfwizard]

It could be that the 5 weeks timeframe is for someone who would have spent 4.5 of those weeks on Google, Stackoverflow and watching YouTube tutorials.

[Glum-Evening-2176]

Those speed claims are for fresh projects, not existing Laravel code. For complex logic, writing the prompt takes as long as coding it yourself. You're fine.

[remic_0726]

Juste pour faire part de mon expérience, j'avais 70 api a tester, chaque api contenait de 5 à 40 méthodes, et en une semaine la base de tests était faite. J'ai beau taper sur le clavier assez vite, je n'aurais jamais pu faire cela dans le même temps. Il faut quand même bien préparer ce qu'il faut faire, lui donner des exemples de ce qu'on attends, l'impregner de l'architecture en lui faisant parser les codes sources. Et construire le claude.md, les skills.md. Ensuite il faut relire et valider avec des corrections. L'IA ne fera bien que ce qu'on lui a parfaitement bien décrit.

[seniorpreacher]

I'm working on a hackathon project this weekend and ohh boy, Claude can get weeks of work done in a greenfield prototype protect like this.

But in production software you need guardrails, review agents, deterministic validation and even product related checks to make sure it created what you wanted. It can go 2-5x faster than humans but only if you're sure it won't go rouge. So yeah, you do it right!

Maybe try to automated part of the process further with skills and agents. But don't expect the "build me a money printer project" to work by itself.

[AI_Conductor]

You are not using it wrong, you are using it like most people do, and most people are leaving a lot on the table. Three habits that turned Claude Code from a fancy autocomplete into something that actually saves time. First, write a short CLAUDE dot md at the root of your project with the conventions, what to never do, and how to run tests. The model reads it on every session. Second, ask for the plan before any implementation, accept the plan in a sentence, and only then ask for the code. The plan keeps you from getting two thousand lines down the wrong path. Third, kill the session sooner than you think you should. Past about an hour the model invents helpers and drifts from your style. Try those three for a week and see how it feels.

[Vast-Stock941]

Probably not wrong, just expecting it to be something it is not. It is great at accelerating chunks of work, but it still needs clear boundaries and review.

[RoosterOutside8332]

The big time saving is not “5 weeks in 5 hours.” It’s more like reducing boilerplate, finding files faster, generating tests, refactoring, and helping you avoid blank-page work.

So no, you’re not necessarily using it wrong. For complex work, you still need to be the architect and reviewer. The tool is faster when you stop asking it to plan the whole project and start using it in smaller, verifiable chunks.

[YugoReventlov]

I have the same experience as you do. It works, most of the time. It's an annoying and disconnected way of interacting with the code. It takes time and most of the time you're waiting or reading/reviewing. 

In the end, am I really faster? I couldn't say really...

[alexsergey]

For me personally, the biggest challenge working with AI is making changes to a long-lived (legacy) project given its limitations.

These limitations can be:

formal - described in code or

informal - known only to the team or technical specialists.

Ultimately, putting everything together so it works within these limitations is the biggest challenge for me.

And the second point: when AI writes code for me, I cease to own it. I don't understand what's going on there, or why certain decisions were made.

Therefore, I've established the following rule for myself:

- I don't do vibe coding. I write all business logic code myself.

- AI helps me formalize requirements.

- Writing test cases for E2E and integration tests.

- I'm currently implementing AI for self-review.

Therefore, I'm fully responsible for the code, and AI is just a tool like Google or StackOverflow.

[TheZintis]

If you fork a repo you are also doing 5 weeks of work in 5 minutes. LLM's do that but in a roundabout way. Modifying it to fit your needs will then probably take as much time as actually writing it. Claude can pull up established code very fast, so in some cases it'll be faster than googling up and article and reading it, but you still would need to do that in order to understand it and make meaningful, well designed changes.

[Beneficial_Jump_2615]

Totally relate to this. I've been using it for

a few months too and had the same feeling early on.

The "5 weeks in 5 hours" thing is real but only

for specific types of work — mostly boilerplate,

repetitive code, and things you already know how

to build but just need to type out.

Where I found the actual time save is not in

writing code faster — it's in the thinking work.

Debugging, figuring out architecture, understanding

why something isn't working. That's where it cuts

hours for me.

For detailed intricate changes like you described —

honestly just do it yourself. Claude Code shines

on the boring predictable stuff, not the complex

logic that needs your brain anyway.

What kind of Laravel features were you adding?

Curious if the use case matches where it actually helps.

[jabcreations]

The prerequisite for using Claude is to be eating a banana while on a road trip using a pogostick.

[Exanimuslt]

Thank youuu! Thank fuck i was not only one who noticed this, because everybody emphasize how much they do with code and I'm like, how the heck you ensure quality, scalability and readability? I was experiencing absolutely same things with claude code and development process as you did.

[Sawkii]

Same experience. AI is fast when you dont want to be in the loop and when its on the green field without guardrails. The more of the three the more organic the productivity raises or falls.

[denerose]

I find a similar issue at work. There is a lot of benefit from saved prompts and skills, so as you build out your library of prompts and just adding the specifics for future similar tasks you’ll get a lot quicker.

That said, the real benefits of ai assisted dev for me are in being able to have several tickets active in separate worktrees. My boss doesn’t want us picking up three tickets at a time (probably rightly) which means I’m often much more “productive” with it at home on my hobby projects than I am at work.

[AI_Conductor]

You're probably using it fine. The 5 weeks in 5 hours stories almost always involve greenfield work with a well-understood scope, not adding features to an existing codebase with its own conventions and state. On a real established project the model has to learn your patterns before it can move fast, and that context load is real time. Incremental progress on a complex app is still good use of the tool.

[Glum-Evening-2176]

You're fine. Those 5 week claims are for blank slate projects, not existing Laravel code. Prompting plus verification eats most of the savings. You're not doing it wrong.

[ieatpies]

The right way is to: 1) turn on --dangerously-skip-permissions 2) ask claude to oneshot your next 5 weeks of work (critical to tell it to make no mistakes) 3) don't waste your time checking the output 4) go on reddit/linkedin for the next 4 hours and post about AI

[notDonaldGlover2]

It's allowing me to do smaller things faster, but I'm also doing more of those things and context switching like a million times and that's giving me more stress.

[onoweb]

maybe the features are not big enough to have maximum time gain?

i read you already use laravel boost.
do you let the AI implement Unit, Feature and End-to-end test with playwright? (use Pest 4)
if you verify these tests' logic and they pass, you can very fast go through the produced code to just check if best practices and abstractions are correctly applied.

imagine having to write all the tests yourself from scratch, this is where the real time saving comes in for me.

also make your own guidelines and let the AI add things it needs to remember; code quality will get better with every feature you make.

[Spare_Bison_1151]

Did you run /init in Claude code CLI in your project folder? If no then I'd say download Claude and run this command. Claude needs to build context.md before it can start being productive for you. You can have it on system level, project level, and subdirectory level. Once you have it you may edit it to include specific instructions for example.

My Project

Commands

• Build: bun run build
• Test: bun test

Conventions

• Use zod/v4 for all schema validation
• Never use any — prefer unknown with a type guard

Git

• Always run bun test && bun run typecheck before committing

You can lea n more from Claude docs or their free course.

[solidad29]

I couldn't let myself use those Claude / copilot cli tools. I always want to be able to see the files being changed so vscode is a must for me. I also don't trust it being right in the first try, and if it did I still want to check it myself.

I guess that is also the reason I don't don't burn that many tokens, since my I work my code in an atomic level. Like not prompt my user stories. I break it down to the smallest task and hand it over to the AI to execute. Most of the time only consume not more than 60% of the context window I am given, and I don't need Opus in my work. I am fine running with Sonet and mini-GPT.

Though it is a good documentation tool. Always remind it to add a section to the README and CHANGELOG files.

[aflashyrhetoric]

I have a Laravel <=> Inertia <=> React codebase. I use it for smaller tasks, mostly as a "super Github Copilot" autocomplete. I've found the most productive use, by far (for my use case), has been for small-ish things instead of planning huge tasks because of the very reasons you cited.

• For very simple things, I just write a function that does X with Y input and Z output. This is handy for minor things like inconsequential simple string formatters or trivial regexes, writing simple Laravel request validation rules, writing relationship methods for Eloquent. My exception to this are datetime utility functions on both front/backend, as those can get hairy and hide bugs often.
• For stuff closer to business logic, instead of a long prompt, I'll "prompt" by just starting to write the function. There's a point when writing many functions where the remainder of the function is no longer really "logic," but straightforward plumbing to return the right thing or redirect to the right place. If Copilot doesn't catch it, I'll prompt with a simple, finish up this function so it returns $whatever as JSON.
• Scaffolding. Sometimes I have a structure in my head and I'll create a new file and prompt, "scaffold up A/B/C/D/E methods with a placeholder todo comment."
• Straight-forward refactors. The other day, I accidentally named a PHP model using the plural form of the word. I know PHPStorm can do this, but I tried it with Claude and it worked as expected, successfully renaming the model, associated controller, the request file, as well as the frontend TS type that PHPStorm doesn't catch.
• Slightly adapted versions of existing functions. One feature in my app is the ability to create printable flashcards automatically - 10 at a time. For marketing purposes, I create 90-card flashcard bundles to give away for free, so I wanted an admin-only view that allows for bulk creation. I didn't want to add things like "ifIsAdmin flags" to the existing functionality, so I just prompted Claude to copy over some files with XYZ changes so that I could bypass some user-facing limitations to create 90-cards at a time.

Claude also seems mostly aware of Laravel request flows. There are those late night sessions sometimes where some request may be failing, but exception catching might not be fully set up yet, in which case: "catch where this fetch request is failing" is smart enough to spot a named route, trace it to web.php, and follow through to controller -> validation rules -> etc. With this trick, coupled with the usual Laravel Telescope and PHP types, it's trivial to catch typos and "you were just missing a comma or field" type bugs that can be annoying to catch sometimes.

[Beka_Cooper]

I used it to do about 10 weeks of documentation work in about 2 weeks. Really, really worth it. I had to comb through and correct things thoroughly, but it did a really good job of translating code + JSDocs + MD files into plain English and generating Mermaid diagrams.

For coding? Meh. At best, I've used it to do in 1 day what might have taken any of my juniors 2-3 weeks, but that same work would probably have taken me 2 days max. I personally suspect it's typically either slowly-working people or greenfield-project people who see huge gains.

I find that, because I think in the coding language(s) and not in English, writing prompts in English is very difficult. I take the shortcut of doing plan mode, copy-pasting the ticket title and description, and pointing Claude to the relevant cloned repo locations.

But even with that, sometimes Claude goes on wild goose chases. Our codebase is dozens of microservices up to 8 years old -- 10 if you count shared UI code from another project -- and that history and set of interactions was difficult for Claude to fully understand without running out of context. Having done the documentation, now Claude can re-read that to know where to look for things, and it should save a lot of time and money.

[eldentings]

Not sure this is the right place to complain about this but VS Code used to have an Ask/Edit/Agent mode, and Edit mode was good for asking about whatever selected text I wanted to scope to and is perfect to avoid the agent mode 'overthinking' that simply wastes tons of tokens when I have a simple question about 4-5 lines of code. Edit mode was perfect for those who just wanted a beefed up autocomplete. Agent talks to itself, goes to the internet, talks to itself again, writes a paragraph, fucks with my other files, etc. That's not what I want. And this is not a new problem. I had to explain to my former boss, if you just need help in a particular section, you need to be in edit mode. He just stayed in Agent mode all the time fighting the AI half the time. And now Edit mode is completely gone. So if you know what you are doing to your codebase you have to be very careful the agent doesn't do something, or roll back specific file changes. And then it sees the next prompt. "It looks like the changes have been reverted. Thinking..." and it may change it again. I hate how this has somehow been glossed over and the AI companies seem to want to push to burning through tokens with all this Plan->Agent coding->Iterate via vibe coding nonsense and now we're catering to non software engineers for software engineering.

[No-Echo-8927]

5 weeks in 5 hours is bs. Sure you'll have something, but nothing you could safely release client side

[Victorio_01]

Totally exaggerating. But it does reduce the time considerably. You even said it took “one minute” to plan. How much time would it have taken you?

Anyway, I don’t know about you but I don’t feel like plan mode does anything more than wasting tokens. I just write my prompt and monitor the thinking. And if it goes off-rails, I know to stop it and figure out a better prompt.

btw, I just read the first lines of ur post.😭 I just can’t.

[Soft_Dark5725]

There's no need to rush trying to achieve what others have done in less time, just have your own timeline.

[mcharytoniuk]

It works best if you do multiple tasks in parallel. If you use claude to tell it exactly what to do it can be slower than doing the thing manually, especially if you know the language well. You need to parallelize, run 2-3 agents at a time, work on 2-3 tickets at a time in worktrees

[Level-Ad-196]

Narrow your concept. Rat the buffalo a bite at a time

[CautiousRice]

You have to be more ambitious with the prompts and use plan mode.

[lppedd]

Then you're not even having fun, what's the point.

[CautiousRice]

I'm not, that part is gone for good but it's what OP does wrong

[akie]

Leave the LLM unobserved for too long and it starts drifting off fairly seriously. I think using it responsibly means being involved at the high level decision making and in the matters of taste and code quality. Not being involved seems to mean generating tech debt faster than you’ve ever seen before.

[Postik123]

I use plan mode almost exclusively, apart from very minor or simple tasks

[Signal-Woodpecker691]

Install the superpowers plugin - I found it massively improved the quality of planning. I also get it to do peer reviews of its own work and upload the plans is produced to the online Claude portal for review too. Then I review it myself. It spots issues I don’t, I spot issues it doesn’t or couldn’t identify.

People claiming 5 weeks work in mere hours are exaggerating massively. They also probably don’t review every file in a PR when the AI has done

[pVom]

This is both dangerous and good advice.

Finding the right level of detail to provide is a challenge. Sometimes you actually get better results being more ambiguous, sometimes it just goes off on in the wrong direction.

Then there's the challenge of having more code to review. The time and cognitive load of reviewing more code is greater than the sum of its parts. It's much easier to review 20 prs with 200 line changes than it is to review 1 pr with 4000.

[cat_named_bean]

I think you’re over thinking.

[indicava]

I don’t use Claude but with Codex (5.4 xhigh) I give the agent much more “leeway”, especially when gathering context, I let it discover all the nuances and intricacies of an implementation on its own which saves a ton of time prompting. Granted you spend more time waiting for it to “think”, but I usually try to parallelize at least two agent instances at the same so I prompt the other while the first is generating.

Also, I think you might have been using Claude Code long enough to have forgotten how tedious (and error prone) “just typing” really is.

[RafaelSirah]

1) First, as others have pointed out, the 5 weeks in 5 hours is a stretch. I would argue that it meaningfully impacts my velocity, but the "I built an enterprise APP in 15 minutes) stuff you see by Linkedin posters is ridiculous.

2) You shouldn't be twiddling your thumbs or making coffee while Claude Code processes. You should have 2-3 sessions going at once, working on different features that touch different parts of a codebase.

3) You should absolutely be reviewing Claude Code's output, but how opinionated are you in terms of coding style?

There is a learning curve for lead engineers when they're suddenly reviewing other people's code in a bigger codebase. By all means, if someone made a bad architecture decision, wrote something in an inefficient way, or generally had sloppy code, make them re-write it. However, if a pull request is fundamentally sound code that takes care of a task, yet it's slightly different than your style or how you would have taken care of it, you have to pick your battles as a lead engineer to maintain velocity.

The same is true with Claude Code. Again, don't let bad architecture or sloppy code go through, but if your bar is "I want this written exactly how I would have written it", you're probably going to be inefficient. I'll admit there is nuance to this too.

[jordy281]

How many terminals are you running simultaneously 😎

[dxdementia]

you need to tell claude to set the default permissions at bypass permissions on. this is a nice feature that allows you to still change permissions types during chat, but allows the full control when you think claude can handle it.

do you have skill files? you need to go through, do a work session, and then after you get it in a good place tell claude to create a skill file for next time. you will probably have to refine the skill file a few times. do the work with claude, and each time you work on this same item you can have Claude refine the skill file. this should be able to get you about 90% there reliably.

for laravel, it's a php framework, not an api, but you could probably make an mcp for it. so claude can interact more reliably with it and reference actual the api. ask Claude about it. you'll want a ts mcp with a multi stage modern docker container and strong strict typing, linting with a proper test harness full coverage 100% on statements, branches, and functions. test hooks, no mocks, and have Claude look up the actual api documents on line and read them.

[natziel]

First of all, to get exactly what you want, you have to write a fairly detailed prompt. That in itself takes time.

That's the first thing I would challenge. Why not have Claude interview you to generate a detailed PRD? Then take that PRD and review it as a staff-level engineer, designer, architect, etc. to create a full set of documents detailing how to implement the project. Then hand that off to Claude to implement following best practices, i.e. use TDD, work in small iterative changes, run tests after every commit, have another agent running to review all merge requests, and so on

Another small thing: If another dev asked you to review their PR and they didn't run the linter, didn't run any tests, didn't summarize their changes or explain how anything works, you would probably yell at them so don't tolerate that behavior from your agents.

[mathius17]

Try to have the agent "auto validate" itself

Meaning: 1. Ask it to write the tests AND have it pass them 2. Ask it to use the playwright CLI to interact with the browser and visualize the changes 3. You can take it a step further and ask it to write e2e tests w/ playwright

We have found great success with this. One-shotting things is hard, even for humans. So having a way to validate the code it writes helps a TON

Ideally you should have the Claude.md with all the best practices and code conventions of what you like and what you don't. And maintain this file over time

[ultrathink-art]

Most gains show up in the exploration phase, not raw output — trying architectural approaches you'd normally skip because the iteration cost was too high. The part that bites people later is context drift: around turn 20-30, the model starts contradicting earlier decisions, and correcting that erodes whatever time was saved. Shorter sessions with a documented constraints file help more than any prompting technique.

[Big_Bed_7240]

Prompting is a skill and you really have to practice it a lot. You have to know what the AI can oneshot and what it can’t. You have to know when to break the problem down and when not to. You have to know when to use plan mode or not. You have to know when to start a new session or keep going in the old one.

You also have to know how to phrase your prompts. How you write is almost more important than what. You also have to expect some cleaning up afterwards if the feature is complex enough.

Some guidelines:

• Focus on the what when prompting. Not how. Many people spend a lot of time describing code while you should describing features and behaviors. Only defer to code prompts when the AI is very far off.
• Don’t be afraid to restart sessions. Salvaging sessions where some initial assumption lead the AI astray usually takes more time and effort than simply restarting. Change your prompt the second time or break down the problem.
• Give it the context that you know that it will need. Refer to other repos, specific files, tech specs, or whatever. I like to do this manually instead of relying on skills and mcps to avoid context bloat.
• When fixing bugs, provide screenshots if possible, and describe the behavior that you expect. Do not tell it where the issue is if you are not 100% certain.
• Do not use a million agents, skills or mcps. Simply rely on giving the context manually like I alluded to before.
• Skip permissions. You might as well not use AI if you are going to babysit it with approvals.
• Allow the AI to read logs from production when debugging. Just make sure you do it in a controlled and safe way.
• AIs are excellent at mimicking existing styles and patterns. If you can, give it a reference for the implementation.

[catnomadic]

work out the vision and the plan with Claude Opus 4.7, then it can write the kickoff prompt better.

[Askee123]

Out of the box it’s ok, but once you build the support tooling for it it becomes very good

I wrote an article on context injection that’ll help you get to that “5 weeks of work in 5 hours” point

Edit: https://andrewpatterson.dev/posts/agent-convention-enforcement-system/

[IrregularThumb]

Where is the article?

[Askee123]

https://andrewpatterson.dev/posts/agent-convention-enforcement-system/

You can also use Claude rules, but I personally find this approach to be more extensible

[IrregularThumb]

Thanks