#developement

First 6 Offers On The Table For 2027 DB TJ Stinson In His 2nd Year EVER Playing Football💥! #DEVELOPEMENT #GTB #TLC

Côte d’ivoire-AIP:Le conseil régional de la Marahoué a annoncé que les travaux du château d’eau de Minfla sont achevés à 80%. 🇮🇪💪🌍💦 #CIV225 #CIV #developement #infrastructure #eau #Sante #abidjan

अयोध्या विज़न - 2047 के अनुरूप अयोध्या को विकसित करने हेतु क्रियान्वित विकास परियोजनाओं की समीक्षा के लिए केरल से पधारे प्रतिनिधिमंडल ने उपाध्यक्ष श्री @VishalSinghIAS जी से विभिन्न विषयों पर चर्चा की। . . . #GoodGovernanceYathra #Ayodhya #developement #ADA @myogiadityanath

AI Coding in Go Is Not the Problem. Unverified AI Coding Is. #golang #developement A response to Erwin Hermanto’s “Using AI Code Assistants for Go: What Works and What Still Fails” Erwin Hermanto recently published a pragmatic assessment of Copilot, Cursor, and Claude for Go development. His conclusion is easy to understand: AI assistants are excellent at boilerplate, tests, migrations, and repetitive work, but become much less reliable when dealing with concurrency, context propagation, and less common APIs. Those observations are valid. But I think they lead to a different conclusion than the one many engineers will take away from the article. The important question in 2026 is no longer: Can an LLM produce correct production Go code from a prompt? It cannot do that reliably. The more relevant question is: Can an agentic engineering system understand the repository, implement a change, run deterministic verification, discover failures, correct them, challenge its own implementation, and only then produce a pull request? That is a fundamentally different development model. And when we look at the problems described in the original article through that lens, many of them become less arguments against AI coding and more requirements for how an AI-native engineering workflow should be designed. The original article identifies the right problems One of Hermanto's strongest examples is a seemingly reasonable concurrent implementation: It contains two classic problems: a loop-variable issue for older Go versions and an unsynchronized write to results. That is exactly the type of AI-generated code developers should be worried about. It looks reasonable. It compiles. Depending on the tests, it may even pass. And yet it is wrong. But the lesson should not be: AI cannot write concurrent Go. The lesson should be: Compilation cannot be our definition of verification. That was true before AI as well. 1. Some AI failures should already be eliminated by the environment Take the loop-variable example. Since Go 1.22, variables declared by a for loop are created for each iteration, specifically eliminating the accidental-sharing problem that caused this famous goroutine bug. So before an AI agent changes code, it should know things such as: An agent should not blindly generate generic Go from whatever it remembers from training. It should inspect the environment first. That does not solve the second problem in the example. Multiple goroutines still cannot safely append to the same slice without synchronization. But Go already provides another layer of protection: Go's race detector is specifically designed to detect concurrent conflicting memory accesses. There is an important caveat: it can only detect races that actually occur in executed code paths. So -race is not a mathematical proof of correctness. But that is precisely why we should combine multiple verification mechanisms instead of expecting either the human or the model to catch everything by inspection. 2. Context propagation should be policy, not prompt luck Another excellent example in the original article is the tendency of assistants to introduce: inside code that should actually respect the caller's cancellation and deadline. That can create extremely unpleasant production problems. A request gets cancelled upstream. The database or API operation continues running. Everything passed unit tests. Then the problem appears under load. Again, however, the answer should not simply be: Be careful when AI writes context-related code. Instead, make context handling an explicit project invariant. For example: This is not just an arbitrary style preference. The Go documentation explicitly says that context should propagate through the call chain and that derived contexts should be created from their parents. Now put those rules into the coding-agent environment. For Claude Code, that could live in: Claude Code supports persistent project instructions and path-specific rules specifically for this type of engineering knowledge. The workflow therefore becomes: We have moved from hoping the model remembers something to designing a system around the invariant. That distinction is critical. 3. Hallucinated APIs become much less frightening when compilation is only step one The original article also describes assistants occasionally inventing methods when working with less common packages or internal wrappers. This is another legitimate LLM weakness. Models are extraordinarily good at generating APIs that look like APIs that should exist. For example: Perfectly plausible. Except perhaps the library exposes: An autocomplete-style workflow can fail here. An agentic workflow should not. The agent should be able to inspect: search the repository, inspect the installed module, read go.mod, and compile the implementation. Then: immediately removes a large class of hallucinated API calls. Again, compilation is not enough. But it is a deterministic filter. The key principle becomes: Do not let the model's memory be the source of truth when the repository or documentation can be the source of truth. 4. The biggest upgrade is giving the agent a feedback loop This may be the most important difference between traditional AI coding assistants and agentic software engineering. A classic workflow looks like this: A better workflow looks like this: This turns development into a closed feedback loop. Anthropic's own Claude Code guidance makes exactly this point: providing the agent with tests, expected outputs, linters, or another verification mechanism is described as one of the highest-leverage improvements you can make to agentic development. That changes the role of the model. The model is no longer expected to be correct on its first attempt. Instead, it is expected to converge toward a verifiable result. That is a much more realistic engineering expectation. 5. Important checks should not depend on the AI remembering them There is still one obvious weakness in saying: “Tell Claude to run the race detector.” What happens when Claude forgets? Exactly. So don't rely on Claude. Make it deterministic. A Go project can have a pipeline roughly like: And for appropriate code: Staticcheck contains an entire category of concurrency checks, including problems such as incorrect WaitGroup.Add placement and lock misuse. Now combine that with CI. Or enforce parts of the workflow directly through agent hooks. Claude Code hooks can run deterministic commands at lifecycle events rather than depending on the LLM to decide whether the command should be executed. That gives us something closer to: Now correctness no longer depends entirely on either: the AI remembering everything, or a human spotting everything. That is much healthier engineering. 6. One AI should not write the code and be the only AI reviewing it There is another major difference between autocomplete and today's agentic tooling. We can separate responsibilities. For example: These agents can operate with different instructions and even isolated context. Claude Code supports specialized subagents for exactly this type of delegated work. For example, a concurrency reviewer could be instructed: That second agent is not infallible either. But it is looking at the implementation from a different context and with a different objective. Then deterministic tooling sits underneath both. That combination is substantially stronger than: Copilot suggested it, therefore ship it. 7. Code review findings should improve future AI work The original article makes another important observation: Claude was good at explaining the concurrency problem once it was pointed out, but that does not help if nobody identifies the problem initially. Agreed. But there is another step we can now take. Suppose a code review discovers: That correction should not disappear inside a closed PR discussion. Add it to the project's agent rules. Suppose another review finds: Add that too. Or: Add it. Claude Code explicitly recommends updating project instructions when the same correction is needed repeatedly or when code review identifies something the agent should have known about the repository. That creates something interesting: The development environment gradually accumulates organizational knowledge. Humans have always done this through: coding standards, architecture documents, tribal knowledge, senior engineers, PR comments. Agentic engineering makes some of that knowledge directly executable by the development process. 8. Tests themselves should increasingly be generated adversarially The original article correctly praises AI-generated table-driven tests, while noting that developers still need to provide domain-specific edge cases. That is another area where I would push the model further. Don't simply ask: Ask another agent: Then fuzz where appropriate. Then race-test it. Now AI is being used on both sides of the problem: And neither side determines the final answer. The machine-verifiable result does. What still requires engineers? All of this does not mean that senior engineers are becoming unnecessary. Quite the opposite. The important engineering work moves upward. Someone still has to determine: What behavior do we actually want? What consistency guarantees matter? Can operations be retried? Is ordering important? What happens during partial failure? What is the security model? What is an acceptable latency? What data is sensitive? Which operations need transactions? What must happen during shutdown? Which architectural trade-offs are acceptable? An LLM can help reason about these questions. It should not silently decide them. Human attention should therefore increasingly move away from: or even: and toward: That is a good transition. The article's warning is still important Hermanto concludes that AI has made the easier majority of Go development faster while the difficult parts remain difficult—and potentially more dangerous because the resulting code looks more polished than it really is. I agree with that warning. Where I disagree is with treating that limitation primarily as a limitation of code generation. It is increasingly a workflow-design problem. The solution is not unlimited trust in AI. But neither is the answer manually distrusting and reviewing every AI-generated line forever. The better model is: From AI-assisted coding to agentic software engineering The first generation of AI coding looked like this: The next generation looks more like: That distinction matters. If our development process is: Ask an LLM to write concurrent Go and assume it is correct, then the criticism in the original article is absolutely justified. But if our process is: Give agents repository context, engineering rules, tools, tests, independent review roles and deterministic verification, then require them to demonstrate that the result satisfies those constraints, we are talking about something quite different. We are no longer just using an AI code assistant. We are building an agentic engineering system. And that leads to what I think is the most important conclusion: The goal isn't to make AI trustworthy enough that verification becomes unnecessary. The goal is to build a development system in which trust is no longer the primary mechanism for achieving correctness. That principle applies equally well to AI-generated code and human-generated code. And that may ultimately be one of the most valuable changes AI brings to software engineering. Original article This post is a response to Erwin Hermanto's Using AI Code Assistants for Go: What Works and What Still Fails, which evaluates Copilot, Cursor, and Claude across practical Go development tasks and highlights concurrency, context propagation, and hallucinated APIs as major remaining weaknesses. Further reading Go 1.22 release notes — loop-variable semantics Go Data Race Detector Go context package documentation Staticcheck checks Claude Code: Best practices Claude Code: Hooks Claude Code: Project memory and CLAUDE.md

हडपसर मधील शेवाळेवाडी परिसरातील ड्रेनेज चा प्रश्न जिल्हाप्रमुखांच्या समन्वयाने सुटला... मांजरी ग्रीन हूड सोसायटीमधील सर्व नागरिकांना भेटून त्यांच्याशी चर्चा करून त्यांनी ड्रेनेजला अडथळा ठरणारी भिंत पाडण्याची परवानगी दिली व काम करण्यास सुरुवात झाली. जय महाराष्ट्र🚩🚩#developement

मिरारोड-भाईंदर रेल्वे स्थानकाचा कायापालट होणार आता क्रांतीची मशाल धगधगणार! #mirabhayandar #developement #infrastructure #rajanvichare #railwaystation #flamingtorch #shivsenauddhavbalasahebthackeray #balasahebthackeray #uddhavthackeray #adityathackeray #shivsainik #yuvasena #thane #Navimumbai

यूपीसीडा औद्योगिक क्षेत्र मेगा फ़ूड पार्क बहेड़ी बरेली में केबल फीडर लाइन बिछाने का कार्य प्रगति पर। #employment #infrastructure #developement

Over 5️⃣0️⃣ resolutions on #Developement adopted by #UNGA today. Important to maintain consensus for the work to reach the #GlobalGoals for our #CommonFuture Thanks to #Senegal 🇸🇳 & the bureau as well as all facilitators for your hard work for #Agenda2030 💗

#String's Event-Driven Programmability is a game-changer for developers looking to create smart contracts and #dApps that can respond automatically to specific events on the blockchain. 🌐🔗 #developers #blockchain

Or imagine building a smart contract that automatically releases funds to a charity when a certain donation threshold is met. 💙🤝

The possibilities are endless with event-driven programmability. And with #String's user-friendly interface and comprehensive documentation, getting started is a breeze. 🌤️👌 Who knows what amazing things you'll create? Let's find out soon! 🌟🚀 #web3 #developement #tech

Works have begun for the construction of the Tamil Cultural Centre near Kalaignar Centenary Jallikattu Arena near #Alanganallur. This Centre is being built in an extent of 40 acres at a cost of Rs. 17.41 crores by @tntourismoffcl #Madurai #Developement #Tourism #InvestInMadurai

Congratulations to Michael, Esther & Abhijit! They have been the precursors of a field that transformed #developement economics. Thank you to Michael & his #Kenya team for the great work on deworming and education in #Africa. My congrats also go to @JPAL & @CEGA_UC.

BREAKING NEWS: The 2019 Sveriges Riksbank Prize in Economic Sciences in Memory of Alfred Nobel has been awarded to Abhijit Banerjee, Esther Duflo and Michael Kremer “for their experimental approach to alleviating global poverty.” #NobelPrize

मिरा रोड-भाईंदर रेल्वे स्थानक हायटेक होणार, क्रांतीची मशाल धगधगणार! #mirabhayandar #developement #infrastructure #rajanvichare #railwaystation #flamingtorch #shivsenauddhavbalasahebthackeray #balasahebthackeray #uddhavthackeray #adityathackeray #shivsainik #yuvasena #thane #navimumbai

Magnifique travail ! Quelque part en Côte d’Ivoire 🇨🇮 #infrastrures #developement #progress

Great speech by PM @narendramodi ji abt #developement of #India & forces that r opposing it shame on #antinational's

Typical training night, 8-10 teams on the regular sized field and 2 teams on the 7v7 field. #developement #Catalonia

Cote d'Ivoire : La ville de Bouaké 🇮🇪 #infrastructure #bouake #developement #gouvci

PM opens Dhaka-Ctg 4-lane highway #Bangladesh #developement

Can’t decide which one to learn Angular or React for frontend! Which one do you suggest? #FrontEnd #developement #React #Angular #webdevelopment

Auto-formatting #JavaScript #Code Style."This Has Been In- #Developement For Some Time & Is In My View Game Change…

Journée de formation avec la fédération des CUMA du Loiret sur les techniques de désherbage mécanique ! Merci à @Agroequipement sur cette journée. #VieDeCUMA #agriculture #developement