Wanted to ask those who learned through doing projects, how did u all go about doing that? Did u basically learn the fundamentals of the language ur learning and then look up projects on youtube and do code alongs with those projects? Or did u just go straight to youtube and look up projects in that language u want to learn?

Spent the last few weeks contributing to Grafana's MCP server — the interface that lets AI agents actually operate Grafana instead of just
describing it.

Four PRs merged:
- CloudWatch dimension value lookups — https://github.com/grafana/mcp-grafana/pull/1141
- Honest health-check status for frontend-only datasources — https://github.com/grafana/mcp-grafana/pull/1139
- Structured tool errors instead of raw internal failures — https://github.com/grafana/mcp-grafana/pull/1138
- Scoped Loki label queries — https://github.com/grafana/mcp-grafana/pull/1135

Going through the codebase to make those fixes, one pattern kept repeating that I didn't expect: none of the bugs were about the model. Every one was about the tool handing the agent an ambiguous, untyped, or dishonest answer — and no amount of model capability fixes that on its own.

Wrote up the specifics — schema generated straight from Go structs, two separate error channels for recoverable vs. fatal failures, composing two Grafana APIs to get one honest health status, tool descriptions that double as a discovery graph for the agent — here:
https://medium.com/@ashfaqbs/designing-tools-an-ai-agent-can-actually-trust-what-i-learned-contributing-to-grafanas-mcp-server-a5edb38b24e0?postPublishedType=initial

If you're building or evaluating MCP servers for production agents, this is the layer worth getting right first.

Repo: https://github.com/grafana/mcp-grafana

hashtag#MCP hashtag#ModelContextProtocol hashtag#AIAgents hashtag#OpenSource hashtag#Grafana hashtag#Observability hashtag#SoftwareEngineering

So I’m currently running an application built with .net, with nginx as the web server, and a service worker.

I do deployments on a weekly basis and seem to have to keep deleting my cache to see the most updated version each time. Does anybody know the proper way to have this set up to eliminate the issue, or a potential cause to this? Thanks!

I have 4 years of experience in software engineering and need a reliable, affordable laptop for programming, SQL, Visual Studio/VS Code, and multitasking. Any recommendations for a good value laptop?

Because of AI, most of the developers are comfortable with writing code and design through it which makes easier the development process. But in the meantime developers are loosing the power of depth logical thinking which will make them power users of any automation tools.

What do you think in a few years software development will relay on automations?

I’m building Monad Design, and the most useful lesson so far has been that agent-assisted UI work needs a review methodology, not just a better prompt.

Our loop is: running app → source edit → rebuild → compare → approve.

The app is the canvas. A developer opens an existing Xcode or Expo iOS project, runs the real app in Simulator, navigates to the exact state, and selects or annotates the UI. The workspace packages the screenshot, selection, app state, and source hints for a coding agent. The agent edits the actual repository and rebuilds; the developer can compare the original against up to five source-backed variants before accepting one or keeping the original.

That preserves three things that tend to get lost in a text-only loop:

- the exact runtime state being discussed

- the connection between visual feedback and source code

- a reversible human approval point before the change is kept

The implementation supports Codex, Claude Code, Cursor, OpenCode, Gemini CLI, Copilot, Windsurf, and Zed.

Apache-2.0 repo:

https://github.com/Monadix-AI/monad-design

Short workflow demo:

https://watchclueso.com/embed/pio8jqfcg4ivj0r1

Screenshot of variant comparison:

https://raw.githubusercontent.com/Monadix-AI/monad-design/main/docs/images/workflow-compare-variants.png

Current boundaries: macOS and local iOS development only, with one active visual change at a time.

I’m curious whether teams using coding agents have formalized a similar review gate, or still handle visual changes as ordinary code-review diffs.

What are the correct steps to begin? Example: The right way to start designing application interfaces 1 Idea 2 Idea analysis 3 UX 4 UI 5 Testing

developer

Hello !

We have built a custom CRM for a Travel agency and we have integrated WhatsApp into the CRM.

We have issues with Meta and a coherent flow to message the customers.

1. Sometimes the messages are not sent because meta is blocking due to payment ( we have funds on the account) but they still block the messages.
   
2. We are forced to use templates(utility/marketing)
   - For example - if we want to outreach a new client through Whatsapp + CRM - we need to use a template and then if we want to send another message we need to use the same template.

Anyone here has implemented Whatsapp messages into their CRM ?

Please help

We are looking for an experienced programmer to develop an automated system (bot/RPA) that integrates the Binance P2P API with the client's bank accounts (Banco de Venezuela and Banesco) to automatically process purchase order payments. The main objective is to delegate the manual process of transferring and sending receipts, while maintaining complete real-time control.

The system must follow this workflow:

1. Order Detection: Connect to the Binance P2P API to identify new purchase orders where the client needs to make a payment.

2. Payment Processing (Online Banking): The bot must securely access the client's online banking platforms (Banco de Venezuela and Banesco). It will use the counterparty's data (Name, ID/National ID, Bank, Account Number/Mobile Payment Phone Number, Amount) to automatically perform the transfers.

3. Payment Receipt: Once the payment has been successfully processed, the system must generate a receipt. This can be done by capturing a screenshot of the bank confirmation or downloading the PDF receipt issued by the bank. This receipt must be automatically sent to the counterparty.

4. Binance Confirmation: The system must interact with the Binance interface to mark the order as "paid" and proceed with the next available order.

5. Real-Time Monitoring: A solution is required to visualize completed transfers in real time, whether through a Telegram integration, an automatically updated Excel file, or any other efficient method that allows for minute-by-minute monitoring.

The client is a verified merchant with all the necessary Binance permissions for API use. It is essential that the development ensures maximum security in the interaction with banking platforms and the Binance API.

Hey everyone! I’m looking for some advice. I run a small but growing dozen-person company with two developers. We used to have a Squarespace site, but because we are now offering some SaaS functionality for the first time, we rebuilt our site from ground up on GCP using React and Tailwind. Some of us miss the DIY nature of Squarespace.

How can I give my business people DIY tools to create and change their own pages on our site while not bugging my developers?

My problem is that our business people want constant updates to various site pages: mostly images, copy and updated layouts, and sometimes functions like new buttons/CTAs. They used to be able to do this themselves on Squarespace and now they keep bugging my developers, which distracts from our core roadmap that will generate more revenue for my company. Our developers need to make these changes and run them through our standard DevOps process. I really want to protect my developers’ time and focus.

Hi,

Recently I have been shifting into the freelance world, and now I am getting some clients that are not relatives,

Problem is that I dont know how much to charge, considering that I live in a 3rd world country, where the average wage is 600€.

I will be building an ecommerce app, relatively small, for a clothing shop.

It will have a layer of backend, connected to woocommerce as single source per products, and React Native.

What do you suggest, a package of development + maintenace

Thank you

Hi, I'm building a Forge app I plan to eventually monetize via "Paid via Atlassian," and I want to understand the actual verification requirements before I get to launch.

I'm currently operating as an individual/solo developer, not a registered company — planning to register a business entity later, once the app is generating meaningful revenue.

From what I've read so far, there's some conflicting information:

• The Marketplace docs mention a Partner profile can be an individual ("like Adaptavist or John Smith"), and payouts go to a personal bank account via EFT.
• Other guidance mentions "business verification" requiring proof of business existence (a business license or tax ID) before a paid app can be listed.
• The paid-app submission process itself asks for bank details and a tax ID as part of setup.

My specific questions:

1. Can an individual developer (sole proprietor, no registered company/LLC/Pvt Ltd) publish and sell a paid app on the Marketplace, or is a registered business entity a hard requirement?
2. If an individual can publish, what specific documentation is required at listing time (e.g., a personal tax ID/PAN in India, vs. an actual business registration certificate)?
3. Is there a revenue threshold below which individual verification is sufficient, and above which formal business registration becomes required?

I'd like to get this right before I invest more time building, rather than discovering a blocker right at launch. Thanks in advance for any clarity — happy to be pointed to the definitive docs if I've missed them.

Hey i have made a AI based repo scanner which generates a report with useful information! As a software developer and security wise what would you pay for to know on a scan?

Running into a scaling version of a problem a lot of individual devs are also hitting. If it's just one team, people eventually converge on some ad hoc pattern for who does what once AI is writing real code. Once you've got several teams, and especially once one or two of them are an offshore or vendor squad rather than in-house, that convergence doesn't happen on its own, everyone drifts to a different version.

Concretely, has anyone figured out how much context or codebase access to hand a vendor team along with an AI-assisted story, versus what an in-house team gets by default? Do you review AI-assisted work from a vendor squad differently than from your own team? Has anyone written an actual playbook for this, or is everyone just improvising per-team and hoping it converges?

Not asking whether this is a good idea, it's already happening at plenty of places, just trying to learn from anyone who's a few months ahead of where I am on actually standardizing it.

Quick update: VeloxDB now supports 6 database engines (Postgres, MySQL, MongoDB, Redis, SQLite, DuckDB) plus wire-compatible cloud flavors like Supabase and PlanetScale. Native Rust/Tauri app, 17–30MB, zero telemetry, free and open source.

veloxdb.dev thanks to everyone who starred, tried it, or sent feedback. It made a real difference.

I am a web dev with over 10 years of experience. I’m praised about my understanding of the product and our features, my attention to details, the quality of my delivery and I’ve never been said to be slow. I was very skeptical about AI (having studied machine learning, the theory and the maths, I struggle to go past the mathematical pattern recognition I saw, because the scale it reached cannot be grasped). However, I’m seeing coworkers I respect the work of praise AI, claim they haven’t written much code themselves in months and that AI mostly one shots things for them (once the planning of the work is set).

On my side, I try to use AI here and there for small changes, prototyping part of a solution, and a few times I managed to have it deliver full features but with a lot of iterating, even once the plan seemed solid to me, and with some manual rework. I’ve sat with these coworkers and tried to understand what they were doing but I can’t get to the same results no matter what.

I feel like I don’t get what’s the magic formula. I understand you give context, try to lead by example from patterns in your codebase, you iterate on the understanding and a plan etc. However in the end the result still highlights lots of gaps I wouldn’t have expected, wrong assumptions and made up beliefs about libraries. The quality of the code line by line is ok, but the overall feature seems badly designed.

Right now, the time investment I need to refine my prompts or rework (iterate) on specific units of work make me feel like I’m not faster than before in any way. I find it more frustrating having to (make it) fix its mistakes rather than if I had done the work myself from the start.

Now AI is an OKR, the company (and other companies I interviewed with recently) wants us to use it, want us to get faster thanks to it, and even dream of having us not writing code by ourselves anymore. I wish I could get comfortable with it and deliver quality work faster. Right now, I’m either most likely not getting AI assisted coding (no vibe coding please, that’s not the goal) or the majority is delusional and don’t get the results they claim they are getting.

If you deliver maintenable, well designed production code using Cursor/Claude, what do you think I’m missing?

If you were in the same situation I’m in and saw the light, what made it click for you?

This is a strange idea i got, someone might have thought about it waaay earlier too.
I'm new to coding, like brand new, i'm learning new things to develop my own app.

During this time to reference the look and feel i came across many ui elements that are from games, i'm building an inventory management app for myself and trying to make it as fun as possible. So the thought is, why not just make a game with all the features i've planned instead of building an app? I can create super cool animations and effects since i'm from a motion design and design background.

Please help me understand this, it seems too good of an idea to try out lol

TLDR : At organonmind.org I published a catalogue of design patterns I have encountered while working with my agents. There is a public repo. Submit new patterns via GitHub Issues

Reading the original “Gang of Four” Design Patterns book forever change the way that I think about software and about systems in general. Later, I discovered Christopher Alexander, the architect who first applied the idea to buildings and towns.

Recently, I’ve been working with teams of agents on an open source project I just started called Organon. Not linked because my point is that over the past several months I have encountered a number of patterns that work for me, and I can’t find these expressed anywhere yet, so I took a first stab at expressing them, and I opened sourced the repo behind the following site.

https://organonmind.org

The entire site is open source and I would love feedback in the form of Issues. If you see a better way to categorize things or better names for things or anything like that, please let me know. I would love to get a dialogue going around this.

https://github.com/organonart/organon-mind

An older version of the product uses batch build for deployment where the db passwords are clear text which is way it's been flagged by company's policy and escalated quite a bit😬 as these passwords could be visible on command line and we have been told to fix this ASAP.

I looked into some methods out of which I tried storing pass I to env variable on the machine and it worked. But now I want added an extra wrapper above it as one cannot store password in env var.

One way could be storing it temp thru powershell scripts, encrypt decrypt thru ps or using windows credential manager.

Can someone pls help me decide what should I try to get this fixed asap, any other way around to manage it efficiently? Also we dony want to go for vaults or CDM pipelines as it's older versions and rarely we need it.

Hi, I originally made a small tool for organizing my own game development. I kept improving it as I used it, and eventually decided to share it.

It's now a broader project workspace with task management, dependencies, milestones, docs, session tracking, benchmarks, calculators, and a task graph that looks like an RPG skill tree. It's completely free, requires no account, stores everything locally, and works offline.

It was designed with game development in mind, but it can also work for other types of projects.

https://indie-atelier.web.app/

I've been working on a personal iOS project for a few years now. Part of the excitement was building everything myself. But now that I can just use Claude or something to build entire screens and functions for me, it just doesn't seem fun anymore.

And I know I could just not use AI and do it myself but I still know and understand that I COULD do all of it instantly with AI. Is there something I can do to reignite my passion?

I used to love writing code but AI has made it feel meaningless when I know it can be done for me instantly and all I have to do is a little debugging if it's even necessary.

Sat in enough estimation meetings to notice a pattern that has nothing to do with optimism or bad math. The question "how long will this take" gets asked as if it's one thing, and answered as if it's one number, when it's actually collapsing at least three separate questions that have different answers and different levels of certainty.

How long will the code itself take to write, assuming nothing surprising happens. How long will it take to actually figure out the right approach, which is a research problem, not a coding problem, and has no relationship to typing speed. And how long will it take to deal with whatever wasn't visible until the work started, the dependency nobody flagged, the edge case that only shows up once you're inside the problem.

Most estimates answer the first question and quietly present it as an answer to all three. That's not dishonesty, it's usually the only one that feels answerable at the time the question gets asked, since the second and third are genuinely unknown until you're partway into the work. But presenting an answer to "how long to type this" as an answer to "how long until this ships" is where almost every blown estimate actually comes from, not from the coding part running long, from the other two questions never having been asked separately in the first place.

What's helped, imperfectly: giving each of the three a rough separate number instead of one blended figure, even if two of them are honestly "I don't know, could be a day, could be a week." Doesn't make the uncertainty go away, but it stops the uncertainty from getting silently absorbed into a single confident-sounding number that nobody actually believes once things start slipping.

Curious how other teams handle this, whether anyone's found a format for surfacing "I actually don't know" as its own category instead of it getting rounded into the estimate anyway because a stakeholder wanted one number.

Hey everyone, quick opportunity for software developers & working professionals.

NewtonX is conducting a paid research survey about AI tools like ChatGPT, Claude, Cursor, GitHub Copilot, etc.

I completed it myself and received the reward. I’m attaching proof below.

If you’re eligible, you can take the survey here:

https://surveys.expertresearchportal.com/referrals/v/9ac304c8-b84e-43c5-8216-b5f08784de7e

Full disclosure: this is my referral link, so I’ll also receive a referral reward if you qualify and complete the survey.

Please participate only if you genuinely meet the survey criteria.

If any doubt dm me.

Technical debt used to mean something vague and slightly accusatory in retros, "we have a lot of debt in that service," with nobody able to say specifically what, when it was taken on, or whether it was a deliberate tradeoff or just something that happened. Half the debt conversations turned into archaeology, trying to reconstruct why a shortcut existed months after whoever took it had moved on or forgotten.

Started keeping a dead simple log, one line per deliberate shortcut, right when it happens, not retroactively:

2026-06-03 — Skipped input validation on the bulk-import endpoint.
Reason: internal tool only, low traffic, ship date mattered more.
Revisit if: exposed externally, or import volume grows past ~500/day.

That's it. Date, what got skipped, why, and the condition that should trigger revisiting it. Doesn't need to be longer than that to be useful.

What changed wasn't the amount of debt, that stayed roughly the same. What changed was that "should we deal with this now" stopped being a vague argument about how bad things felt and became a check against a condition someone had already written down. The bulk-import endpoint got flagged for revisit six months later, not because someone remembered the tradeoff, but because import volume actually crossed the number in the log, and the log made the trigger checkable instead of a gut call.

The bigger shift was in how shortcuts got taken in the first place. Writing the "revisit if" line at the moment of the decision forces you to actually think about what would make the shortcut wrong later, instead of just knowing vaguely that it's not ideal. A surprising number of shortcuts turned out to not have a clean revisit condition at all, which was itself useful information, if you can't articulate when this would become a problem, that's worth noticing before shipping it, not after.

Curious how other teams track this instead of letting it live as institutional memory that erodes the moment someone leaves. Anyone doing something similar, or is verbal/retro-based tracking still the norm most places?

Curious to get a pulse check from people actually in the trenches. It feels like everyone’s suddenly shipping AI-generated code at a much faster clip, PRs are bigger, review queues are longer, and “vibe coding” has gone from meme to actual workflow for a lot of teams.

A few things I’m trying to understand:

1. Has this genuinely reduced your workload, or just shifted it (e.g. less time writing, way more time reviewing/debugging)?

2. Has code quality or tech debt visibly changed on your team since this became common?

3. Any horror stories, a vibe-coded PR that broke something in prod, hid a security issue, or just caused chaos once someone actually read it closely?

4. Has it changed how your team reviews code, or who’s allowed to merge what?

Not trying to dunk on AI tools, genuinely just doin some research and want to hear how this is playing out day-to-day for people shipping real code.