Sr. Content Developer at Microsoft, working remotely in PA, TechBash conference organizer, former Microsoft MVP, Husband, Dad and Geek.
149857 stories
·
33 followers

ReSharper and Rider 2025.3.0.3: A Fresh Set of Updates Released

1 Share

Another set of updates for the 2025.3 versions of ReSharper and Rider has just been released.  Let’s take a look at what’s been improved.

ReSharper 2025.3.0.3

The most notable fix of this build is that extension methods from source-only NuGet packages are now recognized correctly in the editor and by InspectCode. [RSRP-502165]. You can find the complete list of issues resolved in this build on our issue tracker.

Rider 2025.3.0.3

The update brings the following fixes:

  • Automatic package restore now works correctly again. [RIDER-132445
  • Rider now correctly detects the ApplicationId from the Android manifest in .NET MAUI projects. [RIDER-132426
  • Occurrence markers are now shown correctly on the scrollbar again when placing the caret on a symbol in C# code. [RIDER-132306
  • Identifier-under-cursor markers are now shown correctly in the error stripe gutter again. [RIDER-132345]
  • Solution-Wide Analysis performance has been restored. Code analysis no longer pauses for several seconds after edits, and highlights update instantly again. [RIDER-132309
  • Find in Files now returns results reliably again. [RIDER-132487]
  • A regression in the Blazor editor support that prevented Razor files from loading has been fixed. [RIDER-132327
  • Extension methods from source-only NuGet packages are now recognized correctly in the editor and by InspectCode. [RSRP-502165]

For the full list of issues we’ve resolved in this build, please refer to our issue tracker.


You can download the latest builds from our website (Rider, ReSharper) or via the Toolbox App. You can also update Rider as a snap.

Read the whole story
alvinashcraft
25 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

Platform Engineering’s True Value Is in Application Development

1 Share
Software developer at work.

The ultimate goal of platform engineering is not straightforward and deserves nuanced consideration. Platform engineering is a discipline, within the cloud native world, that serves as an aid to streamline workflows and ensure consistency. But that’s not all.

While it is true that platform engineering is fundamental to building internal tools that optimize operations and facilitate platform teams, its ultimate impact extends further than managing complex sets of organizational and technical practices.

In essence: Platform engineering is not an end in itself, because the core value of platform engineering initiatives lies in application development.

Understanding that platform engineering pursues a further goal and internal developer platforms (IDPs) serve a broader scope, means to acknowledge that the platform itself is a conduit and application development is the true enabler of value generation, distribution and maintenance.

IDP: Your Self-Service Foundation To Boost Productivity

The shift from traditional, often cumbersome, infrastructure provisioning to a self-service model is somehow revolutionary for application development. Historically, developers have faced significant delays and friction due to heavy reliance on other teams even for basic infrastructure and operational needs.

IDPs have greatly eased developers from most of their cognitive burden, allowing them to perform with unmatched speed and focus on innovation, business logic and distribution of value rather than underlying complexities.

Basically, IDPs turn infrastructure resources, tools and services into highly functional and automated components to get the job done faster, smoother and more securely. The developer becomes a craftsman entitled to build applications, relying on a solid foundation with ready-made tools.

The gateway to such a foundation is the internal developer portal: a consolidated and intuitive interface that gives seamless access to platform capabilities and resources with service discoverability, documentation, scaffolding templates and customizable dashboards.

Developers can single-handedly provision and configure their own resources by following predetermined best practices and recommendations, while pre-approved tools and configurations ensure total alignment with security, architecture and compliance guidelines that developers and even AI agents can actively use.

Accelerate The Entire Development Life Cycle

Platforms aim to consolidate and industrialize the end-to-end software production process within a single hub, granting velocity, governance and compliance at every stage beyond just backend or API provisioning. Here are some examples:

  • A developer wants to create a new microservice and expose it via an API endpoint. Instead of manually configuring routing, load balancing and security policies, they use the platform’s self-service interface to define the new service and its endpoint. The platform automatically provisions the necessary infrastructure, sets up routing via an API gateway and applies default security measures, making the service immediately accessible and secure.
  • A frontend developer needs to build a complex, modular user interface by integrating multiple components and legacy systems. Rather than coding everything from scratch, the developer can use a no-code/low-code tool. This allows visually assembling pages by dragging and dropping pre-built components (tables, forms, charts) and integrating micro-frontends built with different technologies or even legacy applications through iFrames. The platform accelerates frontend creation, ensures consistency and reduces integration complexity, enabling faster delivery of a polished user experience without deep frontend framework expertise.
  • AI-native platforms with integrated AI assistants and Model Context Protocol (MCP) servers can streamline processes even more, enabling multiple use cases and bringing in diverse roles. A chief information security officer can ask the assistant to generate an audit report for all configuration changes in a specific project over the last month, including who made each change and when. The MCP server is the middleware that allows context-aware interactions between AI systems and enterprise live data, enforcing monitoring and compliance without manual efforts.

From Productivity To Accelerated Business Results

The platform’s value is directly proportional to the speed at which developers can release new features and solutions. Reduced cognitive load for developers means they can concentrate on creative problem-solving and efficient implementation of business logic.

Think about a self-service film studio fully equipped with state-of-the-art cameras, lighting and sound stages, all readily accessible. Easily, the true value is not the studio itself, but the blockbuster films (applications) that the directors and crew (developers) can now produce seamlessly, faster and at a higher quality, because they have immediate, on-demand access to every tool they need, significantly boosting their creative output and productivity.

In essence, a modern manufacturing assembly line — the developer platform — is valuable not because of its sophisticated machines, but because it enables the production of finished products, or developed applications, at an unprecedented rate, making the company meet market demand and grow.

The impact of a self-service approach is actually measurable: This velocity translates to business metrics like reduced time to market, increased deployment frequency, faster experimentation and a quicker response to competitor actions. Therefore, benefits are substantial for both developers and organizations: Complete autonomy, infrastructure and operational standardization, accelerated deployments, scalable automation and enhanced productivity, accelerate the software development life cycle (SDLC )and increase the return on investment (ROI).

Self-Service App Development: Discover, Compose, Reuse

Self-service application development is achievable through modular approaches such as composability.

If the internal developer portal is the interactive veil bridging the actionable software and hidden assets, the software catalog is the foundational registry to discover and organize these assets. Composable platforms often feature a prominent marketplace, which is a more visible and manifested counterpart of the software catalog and typically includes templates, plugins, APIs, data bundles and applications.

At the heart of composability, there’s the principle of assembling new solutions or modifying existing ones. This approach not only speeds up the SDLC but also offers greater resource visibility to other functional areas, minimizing redundancy.

Intelligent dashboards and AI agentic workflows can significantly enhance the entire process, assisting developers with routine tasks and debugging, providing context-aware iterations tailored to specific needs or supporting informed business decisions.

Developers as Customers, Value as the Outcome

Platform engineering isn’t an end in itself. Its core premise lies in a strategic initiative whose primary purpose is to help developers build applications.

Somehow, the platform acts as a product and its developers perform as active customers. But a platform can be a successful product only if its infrastructure remains invisible to the developers. In other words, a curated ecosystem that allows developers to focus only on solving business problems and producing value for the organization.

Platform engineering realizes tangible ROI when it directly empowers application developers and product teams, triggering a virtuous cycle of cost savings, risk reduction and increased revenue.

Organizations that successfully implement a holistic internal platform might have more possibilities to ensure long-term growth and innovation, becoming more agile and responsive to market demands.

By prioritizing the developer experience and equipping software engineers with robust, self-service tools, platform engineering directly fuels the engine of business value and market competitiveness.

The post Platform Engineering’s True Value Is in Application Development appeared first on The New Stack.

Read the whole story
alvinashcraft
26 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

Letting the Creative Process Shape a WebGL Portfolio

1 Share
Exploring how experimenting with Three.js, React Three Fiber, and GSAP shaped the final experience.



Download video: https://codrops-1f606.kxcdn.com/codrops/wp-content/uploads/2025/11/Kapture-2025-05-29-at-16.07.48.mp4?x49452



Download video: https://codrops-1f606.kxcdn.com/codrops/wp-content/uploads/2025/11/test-layout-copie-2.mp4?x49452



Download video: https://codrops-1f606.kxcdn.com/codrops/wp-content/uploads/2025/11/portal.mp4?x49452



Download video: https://codrops-1f606.kxcdn.com/codrops/wp-content/uploads/2025/11/Kapture-2025-07-24-at-15.33.01.mp4?x49452



Download video: https://codrops-1f606.kxcdn.com/codrops/wp-content/uploads/2025/11/project-titles-copie-2.mp4?x49452



Download video: https://codrops-1f606.kxcdn.com/codrops/wp-content/uploads/2025/11/Kapture-2025-11-10-at-12.17.59.mp4?x49452



Download video: https://codrops-1f606.kxcdn.com/codrops/wp-content/uploads/2025/11/morph-svg-copie.mp4?x49452



Download video: https://codrops-1f606.kxcdn.com/codrops/wp-content/uploads/2025/11/morph-svg-final.mp4?x49452



Download video: https://codrops-1f606.kxcdn.com/codrops/wp-content/uploads/2025/11/Kapture-2025-09-23-at-10.25.21.mp4?x49452



Download video: https://codrops-1f606.kxcdn.com/codrops/wp-content/uploads/2025/11/Kapture-2025-11-10-at-19.03.08.mp4?x49452
Read the whole story
alvinashcraft
26 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

The Accessibility Problem With Authentication Methods Like CAPTCHA

1 Share

The Completely Automated Public Turing test to tell Computers and Humans Apart (CAPTCHA) has become ingrained in internet browsing since personal computers gained momentum in the consumer electronics market. For nearly as long as people have been going online, web developers have sought ways to block spam bots.

The CAPTCHA service distinguishes between human and bot activity to keep bots out. Unfortunately, its methods are less than precise. In trying to protect humans, developers have made much of the web inaccessible to people with disabilities.

Authentication methods, such as CAPTCHA, typically use image classification, puzzles, audio samples, or click-based tests to determine whether the user is human. While the types of challenges are well-documented, their logic is not public knowledge. People can only guess what it takes to “prove” they are human.

What Is CAPTCHA?

A CAPTCHA is a reverse Turing test that takes the form of a challenge-response test. For example, if it instructs users to “select all images with stairs,” they must pick the stairs out from railings, driveways, and crosswalks. Alternatively, they may be asked to enter the text they see, add the sum of dice faces, or complete a sliding puzzle.

Image-based CAPTCHAs are responsible for the most frustrating shared experiences internet users have — deciding whether to select a square when only a small sliver of the object in question is in it.

Regardless of the method, a computer or algorithm ultimately determines whether the test-taker is human or machine. This authentication service has spawned many offshoots, including reCAPTCHA and hCAPTCHA. It has even led to the creation of entire companies, such as GeeTest and Arkose Labs. The Google-owned automated system reCAPTCHA requires users to click a checkbox labeled “I’m not a robot” for authentication. It runs an adaptive analysis in the background to assign a risk score. hCAPTCHA is an image-classification-based alternative.

Other authentication methods include multi-factor authentication (MFA), QR codes, temporary personal identification numbers (PINs), and biometrics. They do not follow the challenge-response formula, but serve fundamentally similar purposes.

These offshoots are intended to be better than the original, but they often fail to meet modern accessibility standards. Take hCaptcha, for instance, which uses a cookie to let you bypass the challenge-response test entirely. It’s a great idea in theory, but it doesn’t work in practice.

You’re supposed to receive a one-time code via email that you send to a specific number over SMS. Users report receiving endless error messages, forcing them to complete the standard text CAPTCHA. This is only available if the site explicitly enabled it during configuration. If it is not set up, you must complete an image challenge that does not recognize screen readers.

Even when the initial process works, subsequent authentication relies on a third-party cross-site cookie, which most browsers block automatically. Also, the code expires after a short period, so you have to redo the entire process if it takes you too long to move on to the next step.

Why Do Teams Use CAPTCHA And Similar Authentication Methods?

CAPTCHA is common because it is easy to set up. Developers can program it to appear, and it conducts the test automatically. This way, they can focus on more important matters while still preventing spam, fraud, and abuse. These tools are supposed to make it easier for humans to use the internet safely, but they often keep real people from logging in.

These tests result in a poor user experience overall. One study found users wasted over 819 million hours on over 512 billion reCAPTCHA v2 sessions as of 2023. Despite it all, bots prevail. Machine learning models can solve text-based CAPTCHA within fractions of a second with over 97% accuracy.

A 2024 study on Google’s reCAPTCHA v2 — which is still widely used despite the rollout of reCAPTCHA v3 — found bots can solve image classification CAPTCHA with up to 100% accuracy, depending on the object they are tasked with identifying. The researchers used a free, open-source model, which means that bad actors could easily replicate their work.

Why Should Web Developers Stop Using CAPTCHA?

Authentication methods like CAPTCHA have an accessibility problem. Machine learning advances forced these services to grow increasingly complex. Even still, they are not foolproof. Bots get it right more than people do. Research shows they can complete reCAPTCHA within 17.5 seconds, achieving 85% accuracy. Humans take longer and are less accurate.

Many people fail CAPTCHA tests and have no idea what they did wrong. For example, a prompt instructing users to “select all squares with traffic lights” seems simple enough, but it gets complicated if a sliver of the pole is in another square. Should they select that box, or is that what an algorithm would do?

Although bot capabilities have grown by magnitudes, humans have remained the same. As tests get progressively more difficult, they feel less inclined to attempt them. One survey shows nearly 59% of people will stop using a product after several bad experiences. If authentication is too cumbersome or complex, they might stop using the website entirely.

People can fail these tests for various reasons, including technical ones. If they block third-party cookies, have a local proxy running, or have not updated their browser in a while, they may keep failing, regardless of how many times they try.

Authentication Issues With CAPTCHA

Due to the reasons mentioned above, most types of CAPTCHA are inherently inaccessible. This is especially true for people with disabilities, as these challenge-response tests were not designed with their needs in mind. Some of the common issues include the following:

Issues Related To Visuals And Screen Reader Use

Screen readers cannot read standard visual CAPTCHAs, such as the distorted text test, since the jumbled, contorted words are not machine-readable. The image classification and sliding puzzle methods are similarly inaccessible.

In one WebAIM survey conducted from 2023 to 2024, screen reader users agreed CAPTCHA was the most problematic item, ranking it above ambiguous links, unexpected screen changes, missing alt text, inaccessible search, and lack of keyboard accessibility. Its spot at the top has remained largely unchanged for over a decade, illustrating its history of inaccessibility.

Issues Related To Hearing and Audio Processing

Audio CAPTCHAs are relatively uncommon because web development best practices advise against autoplay audio and emphasize the importance of user controls. However, audio CAPTCHAs still exist. People who are hard of hearing or deaf may encounter a barrier when attempting these tests. Even with assistive technology, the intentional audio distortion and background noise make these samples challenging for individuals with auditory processing disorders to comprehend.

Issues Related To Motor And Dexterity

Tests requiring motor and dexterity skills can be challenging for those with motor impairments or physical disabilities. For example, someone with a hand tremor may find the sliding puzzles difficult. Also, the image classification tests that load more images until none that fit the criteria are left may pose a challenge.

Issues Related To Cognition And Language

As CAPTCHAs become increasingly complex, some developers are turning to tests that require a combination of creative and critical thinking. Those that require users to solve a math problem or complete a puzzle can be challenging for people with dyslexia, dyscalculia, visual processing disorders, or cognitive impairments.

Why Assistive Technology Won’t Bridge The Gap

CAPTCHAs are intentionally designed for humans to interpret and solve, so assistive technology like screen readers and hands-free controls may be of little help. ReCAPTCHA in particular poses an issue because it analyzes background activity. If it flags the accessibility devices as bots, it will serve a potentially inaccessible CAPTCHA.

Even if this technology could bridge the gap, web developers shouldn’t expect it to. Industry standards dictate that they should follow universal design principles to make their websites as accessible and functional as possible.

CAPTCHA’s accessibility issues could be forgiven if it were an effective security tool, but it is far from foolproof since bots get it right more than humans do. Why keep using a method that is ineffective and creates barriers for people with disabilities?

There are better alternatives.

Principles For Accessible Authentication

The idea that humans should consistently outperform algorithms is outdated. Better authentication methods exist, such as multifactor authentication (MFA). The two-factor authentication market will be worth an estimated $26.7 billion by 2027, underscoring its popularity. This tool is more effective than a CAPTCHA because it prevents unauthorized access, even with legitimate credentials.

Ensure your MFA technique is accessible. Instead of having website visitors transcribe complex codes, you should send push notifications or SMS messages. Rely on the verification code autofill to automatically capture and enter the code. Alternatively, you can introduce a “remember this device” feature to skip authentication on trusted devices.

Apple’s two-factor authentication approach is designed this way. A trusted device automatically displays a six-digit verification code, so they do not have to search for it. When prompted, iPhone users can tap the suggestion that appears above their mobile keyboard for autofill.

Single sign-on is another option. This session and user authentication service allows people to log in to multiple websites or applications with a single set of login credentials, minimizing the need for repeated identity verification.

One-time-use “magic links” are an excellent alternative to reCAPTCHA and temporary PINs. Rather than remembering a code or solving a puzzle, the user clicks on a button. Avoid imposing deadlines because, according to WCAG Success Criterion 2.2.3, users should not face time limits since those with disabilities may need more time to complete specific actions.

Alternatively, you could use Cloudflare Turnstile. It authenticates without showing a CAPTCHA, and most people never even have to check a box or hit a button. The software works by issuing a small JavaScript challenge behind the scenes to automatically differentiate between bots and humans. Cloudflare Turnstile can be embedded into any website, making it an excellent alternative to standard classification tasks.

Testing And Evaluation Of Accessible Authentication Designs

Testing and evaluating your accessible alternative authentication methods is essential. Many designs look good on paper but do not work in practice. If possible, gather feedback from actual users. An open beta may be an effective way to maximize visibility.

Remember, general accessibility considerations do not only apply to people with disabilities. They also include those who are neurodivergent, lack access to a mobile device, or use assistive technology. Ensure your alternative designs consider these individuals.

Realistically, you cannot create a perfect system since everyone is unique. Many people struggle to follow multistep processes, solve equations, process complex instructions, or remember passcodes. While universal web design principles can improve flexibility, no single solution can meet everyone’s needs.

Regardless of the authentication technique you use, you should present users with multiple authentication options upfront. They know their capabilities best, so let them decide what to use instead of trying to over-engineer a solution that works for every edge case.

Address The Accessibility Problem With Design Changes

A person with hand tremors may be unable to complete a sliding puzzle, while someone with an audio processing disorder may have trouble with distorted audio samples. However, you cannot simply replace CAPTCHAs with alternatives because they are often equally inaccessible.

QR codes, for example, may be difficult to scan for those with reduced fine motor control. People who are visually impaired may struggle to find it on the screen. Similarly, biometrics can pose an issue for people with facial deformities or a limited range of motion. Addressing the accessibility problem requires creative thinking.

You can start by visiting the Web Accessibility Initiative’s accessibility tutorials for developers to better understand universal design. Although these tutorials focus more on content than authentication, you can still use them to your advantage. The W3C Group Draft Note on the Inaccessibility of CAPTCHA provides more relevant guidance.

Getting started is as easy as researching best practices. Understanding the basics is essential because there is no universal solution for accessible web design. If you want to optimize accessibility, consider sourcing feedback from the people who actually visit your website.

Further Reading



Read the whole story
alvinashcraft
26 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

BONUS Transactional AI Development - Commit, Validate, and Rollback With Sergey Sergyenko

1 Share

AI Assisted Coding: Treating AI Like a Junior Engineer - Onboarding Practices for AI Collaboration

In this special episode, Sergey Sergyenko, CEO of Cybergizer, shares his practical framework for AI-assisted development built on transactional models, Git workflows, and architectural conventions. He explains why treating AI like a junior engineer, keeping commits atomic, and maintaining rollback strategies creates production-ready code rather than just prototypes.

Vibecoding: An Automation Design Instrument

"I would define Vibecoding as an automation design instrument. It's not a tool that can deliver end-to-end solution, but it's like a perfect set of helping hands for a person who knows what they need to do."

 

Sergey positions vibecoding clearly: it's not magic, it's an automation design tool. The person using it must know what they need to accomplish—AI provides the helping hands to execute that vision faster. This framing sets expectations appropriately: AI speeds up development significantly, but it's not a silver bullet that works without guidance. The more you practice vibecoding, the better you understand its boundaries. Sergey's definition places vibecoding in the evolution of development tools: from scaffolding to co-pilots to agentic coding to vibecoding. Each step increases automation, but the human architect remains essential for providing direction, context, and validation.

Pair Programming with the Machine

"If you treat AI as a junior engineer, it's very easy to adopt it. Ah, okay, maybe we just use the old traditions, how we onboard juniors to the team, and let AI follow this step."

 

One of Sergey's most practical insights is treating AI like a junior engineer joining your team. This mental model immediately clarifies roles and expectations. You wouldn't let a junior architect your system or write all your tests—so why let AI? Instead, apply existing onboarding practices: pair programming, code reviews, test-driven development, architectural guidance. This approach leverages Extreme Programming practices that have worked for decades. The junior engineer analogy helps teams understand that AI needs mentorship, clear requirements, and frequent validation. Just as you'd provide a junior with frameworks and conventions to follow, you constrain AI with established architectural patterns and framework conventions like Ruby on Rails.

The Transactional Model: Atomic Commits and Rollback

"When you're working with AI, the more atomic commits it delivers, more easy for you to kind of guide and navigate it through the process of development."

 

Sergey's transactional approach transforms how developers work with AI. Instead of iterating endlessly when something goes wrong, commit frequently with atomic changes, then rollback and restart if validation fails. Each commit should be small, independent, and complete—like a feature flag you can toggle. The commit message includes the prompt sequence used to generate the code and rollback instructions. 

This approach makes the Git repository the context manager, not just the AI's memory. When you need to guide AI, you can reference specific commits and their context. This mirrors trunk-based development practices where teams commit directly to master with small, verified changes. The cost of rollback stays minimal because changes are atomic, making this strategy far more efficient than trying to fix broken implementations through iteration.

Context Management: The Weak Point and the Solution

"Managing context and keeping context is one of the weak points of today's coding agents, therefore we need to be very mindful in how we manage that context for the agent."

 

Context management challenges current AI coding tools—they forget, lose thread, or misinterpret requirements over long sessions. Sergey's solution is embedding context within the commit history itself. Each commit links back to the specific reasoning behind that code: why it was accepted, what iterations it took, and how to undo it if needed. This creates a persistent context trail that survives beyond individual AI sessions. When starting new features, developers can reference previous commits and their context to guide the AI. The transactional model doesn't just provide rollback capability—it creates institutional memory that makes AI progressively more effective as the codebase grows.

TDD 2.0: Humans Write Tests, AI Writes Code

"I would never allow AI to write the test. I would do it by myself. Still, it can write the code."

 

Sergey is adamant about roles: humans write tests, AI writes implementation code. This inverts traditional TDD slightly—instead of developers writing tests then code, they write tests and AI writes the code to pass them. Tests become executable requirements and prompts. This provides essential guardrails: AI can iterate on implementation until tests pass, but it can't redefine what "passing" means. The tests represent domain knowledge, business requirements, and validation criteria that only humans should control. Sergey envisions multi-agent systems where one agent writes code while another validates with tests, but critically, humans author the original test suite. This TDD 2.0 framework (a talk Sergey gave at the Global Agile Summit) creates a verification mechanism that prevents the biggest anti-pattern: coding without proper validation.

The Two Cardinal Rules: Architecture and Verification

"I would never allow AI to invent architecture. Writing AI agentic coding, Vibecoding, whatever coding—without proper verification and properly setting expectations of what you want to get as a result—that's the main mistake."

 

Sergey identifies two non-negotiables. First, never let AI invent architecture. Use framework conventions (Rails, etc.) to constrain AI's choices. Leverage existing code generators and scaffolding. Provide explicit architectural guidelines in planning steps. Store iteration-specific instructions where AI can reference them. The framework becomes the guardrails that prevent AI from making structural decisions it's not equipped to make. Second, always verify AI output. Even if you don't want to look at code, you must validate that it meets requirements. This might be through tests, manual review, or automated checks—but skipping verification is the fundamental mistake. These two rules—human-defined architecture and mandatory verification—separate successful AI-assisted development from technical debt generation.

Prototype vs. Production: Two Different Workflows

"When you pair as an architect or a really senior engineer who can implement it by himself, but just wants to save time, you do the pair programming with AI, and the AI kind of ships a draft, and rapid prototype."

 

Sergey distinguishes clearly between prototype and production development. For MVPs and rapid prototypes, a senior architect pairs with AI to create drafts quickly—this is where speed matters most. For production code, teams add more iterative testing and polishing after AI generates initial implementation. The key is being explicit about which mode you're in. The biggest anti-pattern is treating prototype code as production-ready without the necessary validation and hardening steps. When building production systems, Sergey applies the full transactional model: atomic commits, comprehensive tests, architectural constraints, and rollback strategies. For prototypes, speed takes priority, but the architectural knowledge still comes from humans, not AI.

The Future: AI Literacy as Mandatory

"Being a software engineer and trying to get a new job, it's gonna be a mandatory requirement for you to understand how to use AI for coding. So it's not enough to just be a good engineer."

 

Sergey sees AI-assisted coding literacy becoming as fundamental as Git proficiency. Future engineering jobs will require demonstrating effective AI collaboration, not just traditional coding skills. We're reaching good performance levels with AI models—now the challenge is learning to use them efficiently. This means frameworks and standardized patterns for AI-assisted development will emerge and consolidate. Approaches like AAID, SpecKit, and others represent early attempts to create these patterns. Sergey expects architectural patterns for AI-assisted development to standardize, similar to how design patterns emerged in object-oriented programming. The human remains the bottleneck—for domain knowledge, business requirements, and architectural guidance—but the implementation mechanics shift heavily toward AI collaboration.

Resources for Practitioners

"We are reaching a good performance level of AI models, and now we need to guide it to make it impactful. It's a great tool, now we need to understand how to make it impactful."

 

Sergey recommends Obie Fernandez's work on "Patterns of Application Development Using AI," particularly valuable for Ruby and Rails developers but applicable broadly. He references Andrey Karpathy's original vibecoding post and emphasizes Extreme Programming practices as foundational. The tools he uses—Cursor and Claude Code—support custom planning steps and context management. But more important than tools is the mindset: we have powerful AI capabilities now, and the focus must shift to efficient usage patterns. This means experimenting with workflows, documenting what works, and sharing patterns with the community. Sergey himself shares case studies on LinkedIn and travels extensively speaking about these approaches, contributing to the collective learning happening in real-time.

 

About Sergey Sergyenko

 

Sergey is the CEO of Cybergizer, a dynamic software development agency with offices in Vilnius, Lithuania. Specializing in MVPs with zero cash requirements, Cybergizer offers top-tier CTO services and startup teams. Their tech stack includes Ruby, Rails, Elixir, and ReactJS.

 

Sergey was also a featured speaker at the Global Agile Summit, and you can find his talk available in your membership area. If you are not a member don't worry, you can get the 1-month trial and watch the whole conference. You can cancel at any time.

 

You can link with Sergey Sergyenko on LinkedIn.





Download audio: https://traffic.libsyn.com/secure/scrummastertoolbox/20251127_Sergey_Sergyenko_Thu.mp3?dest-id=246429
Read the whole story
alvinashcraft
27 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

Turkey turkey, turkey turkey turkey

1 Share

Turkey, turkey turkey turkey. Turkey turke turkey (turkey) turkey turkey turkey. Turkey turkey turkey!https://isotropic.org/papers/chicken.pdf





Download audio: https://anchor.fm/s/fa549200/podcast/play/111694877/https%3A%2F%2Fd3ctxlq1ktw2nl.cloudfront.net%2Fstaging%2F2025-10-25%2F413149627-44100-2-8ac93e9b3c4a8.m4a
Read the whole story
alvinashcraft
27 minutes ago
reply
Pennsylvania, USA
Share this story
Delete
Next Page of Stories