Sources

This list focuses on concrete workflows that map to common SDLC stages (Build, Test, Operate, Document), anchored to 2025 capabilities like the VS Code extension, Terminal v2 improvements, and checkpointing. ... Pros - Terminal v2 improves visibility for long-running tasks and iterative prompts. - Checkpoints reduce risk when experimenting with fixes. Cons - Requires disciplined prompting and staged commits; otherwise changes can sprawl. - Flaky tests may mask infra or data issues that need human judgment. Evidence anchors - Terminal v2 and checkpointing are called out in Anthropic News — Enabling Claude Code to work more autonomously (2025). - Staged commits and headless patterns appear in Anthropic Engineering — Best practices (2025). … Pros - Inline diffs aid quick review; the IDE context lowers cognitive load. - Encourages explanation-first changes (ask the model to narrate intent). Cons - Extension availability may evolve; treat beta features as subject to change. - Large-scale refactors still need architectural oversight. Evidence anchors - The extension and inline-diff behavior are described in Anthropic News — Enabling Claude Code to work more autonomously (2025) and the Claude Code overview docs. ... Pros - Keeps documentation current with code changes. - Helps onboard new developers faster with repo‑specific context. Cons - Requires discipline to maintain versioned docs; automation won’t replace judgment. - Sensitive changes (security, compliance) need careful review and access controls. Evidence anchors - Developer workflow guidance and CLAUDE.md patterns are described in Anthropic Engineering — Best practices (2025) and the Claude Code overview docs. ... ## Practical guardrails and setup notes - Keep permissions scoped; log actions, and prefer “commit in stages” to maintain recovery options. - Maintain a CLAUDE.md with repo‑specific instructions and conventions. - Treat generated scripts and configs as drafts—review security and performance before adoption. - Re‑check marketplace or availability notes periodically; late‑2025 features (VS Code extension, Terminal v2, checkpoints) are evolving.

Most people in software engineering are using AI tools like Claude Code, Anthropic Claude, Google Gemini, Cursor, and other AI coding platforms completely wrong. They either ignore AI or blindly copy-paste outputs without understanding what the code is doing — and then wonder why production breaks at 2AM. … What is the problem statement? Uh the [snorts] deploy cycle takes 2 weeks. The datab is {ts:542} a nightmare because of 65 table, foreign keys, all of that. The product search is low. The payment module has compliance {ts:550} but it is coupled and so on.

The core issue is that Claude Code builds what you described, not what you needed. Every product description has gaps. When you describe a feature to a human engineer, they ask questions. “What happens when the user does X?” “How should this behave at scale?” “What’s the auth model?” They fill gaps with experience and questions. Claude Code fills gaps with assumptions. And the assumptions are reasonable. That’s the trap. They’re not random or stupid. They’re the kind of assumptions a competent engineer might make if they had zero context about your market, your users, and your business constraints. Technically sound. Contextually wrong. The result is a codebase where every file looks right in isolation. The architecture diagram makes sense. The data flows are logical. But the foundational assumptions - the ones everything else is built on - might be wrong in ways that only show up when real users with real data hit real edge cases. … We regularly see Claude Code projects with three or four layers of indirection for features that serve a handful of users. The code is beautiful. It’s also impossible to change quickly, which is the one thing early-stage code needs to do well. ### Assumption-heavy architecture Your prompt said “handle user authentication.” Claude Code assumed OAuth2 with email/password, built a full session management system, added password reset flows, and implemented remember-me tokens. Clean implementation. Every piece works. But your users are enterprise buyers. They need SAML SSO. Or your product is consumer-facing and magic links would convert three times better than passwords. Or you’re building a B2B tool where the auth model is organization-based, not individual-based. Claude Code picked the most common pattern. The most common pattern isn’t always your pattern. And auth architecture touches everything. It’s not a feature you swap out. It’s a foundation that everything else sits on. ### Context-dependent quality The first files Claude Code generates are usually excellent. Your initial prompts are detailed. You’re thinking clearly. The foundation gets built well. Then you start building faster. Your prompts get shorter. “Add a dashboard.” “Build the settings page.” “Create the billing flow.” Each prompt builds on the context of everything before it. But that context includes every assumption from every previous generation. … ### Missing operational concerns This is the most consistent gap. Claude Code builds features. It doesn’t build operations. No structured logging. No error tracking integration. No health check endpoints. No rate limiting. No graceful degradation when downstream services fail. No circuit breakers. No monitoring hooks. No alerting thresholds. The code works perfectly in development. It handles the happy path elegantly. But production isn’t the happy path. Production is partial failures, network timeouts, malformed data, and traffic spikes. Claude Code doesn’t think about production because you didn’t describe production. You described features. … ## What a Claude Code audit reveals A SaaS startup came to us after three weeks of building with Claude Code. ... Our audit found three foundational problems. First, zero error monitoring. No Sentry, no structured logging, no way to know when something failed in production. The app would break silently and users would just see blank screens. … ### Ops hardening Add everything Claude Code didn’t. Structured logging. Error tracking. Health checks. Rate limiting. Monitoring. Alerting. Graceful degradation. These aren’t features - they’re the difference between a demo and a product. This is often the fastest fix because it’s additive. You’re not changing existing code. You’re adding the operational layer that Claude Code never builds unless you explicitly ask for it. And even when you ask, it tends to add minimal implementations rather than production-grade observability. … ### Assumption mapping We go through the codebase and document every implicit decision. Auth model, data architecture, API boundaries, error handling strategy, scaling assumptions, security model. For each one, we identify whether it was explicitly specified or implicitly assumed. Then we check each assumption against your actual business requirements. This usually takes two to three days. It produces a clear map of what’s right, what’s wrong, and what’s risky. Most Claude Code projects have two or three foundational assumptions that need changing and a dozen smaller ones that should be addressed before scale. ### Operational audit We check everything that Claude Code doesn’t build by default. Logging, monitoring, error tracking, security headers, rate limiting, input validation depth, graceful degradation, backup and recovery, deployment pipeline, environment configuration management. Most Claude Code projects score well on code quality and poorly on operational readiness. The gap is consistent enough that we have a standard checklist. It covers the thirty-seven operational concerns that Claude Code most commonly misses.

SwiftUI has gained significant attention, yet many teams find that its design and tooling introduce serious obstacles for complex, production-grade apps. Below is a structured overview of the main pain points developers encounter. ## 1. Implicit Styling Makes Advanced Theming Difficult • Context-driven modifiers automatically change fonts, colors, and layout based on parent views. • Customizing these defaults to align with a strict design system often requires deep, undocumented workarounds. • Small projects (≤1 K lines) usually cope, but large codebases spend excessive engineering hours undoing or overriding SwiftUI’s implicit behavior. ## 2. Limited Backwards Compatibility • New SwiftUI APIs (e.g., `NavigationStack`, `Observable` macro) are tied to the most recent iOS, macOS, or watchOS releases. • Shipping the latest OS is unrealistic for many user bases; as a result, teams either drop older devices or implement parallel UIKit code paths—both costly options. • For businesses with wide device support requirements, this incompatibility can directly impact revenue projections. ## 3. Slow Incremental Builds and Previews • SwiftUI’s preview system and dependency-heavy build graph often double or triple compile times compared with Android, Flutter, or React Native equivalents. • Large Swift packages sometimes require clean builds to resolve preview inconsistencies, further slowing iteration. • Longer feedback loops inflate development budgets and delay feature releases. ## 4. Business Risk Assessment Choosing SwiftUI can increase the probability of project delays or missed market windows when: - Your brand demands pixel-perfect, non-standard UI. - You must support users on OS versions > 1 year old. - Rapid iteration speed is critical to product-market fit. Conversely, SwiftUI may still be viable if: • You control the target OS distribution (e.g., first-party Apple apps). • Your UX requirements align with Apple’s Human Interface Guidelines out of the box.

One effect of this is seen when reviewing Swift code: sometimes developers use conventions that don’t take full advantage of Swift’s capabilities, or they misunderstand how certain language features are meant to be used. In this post, I’ll cover the top three issues I tend to see in code reviews of Swift. ## 1. Misunderstanding reference counting and ownership Swift’s memory management is based around a system known as ARC (automatic reference counting). There is no garbage collection mechanism like those found in other languages and platforms. So a misunderstanding or misuse of the ARC system is a common cause of memory leaks and subsequent crashes. Every object in the Swift runtime keeps a count … eventually finishes, it will attempt to perform methods on the object outside of its intended context, which in a best case scenario is inefficient and could affect performance of the application and in a worst case scenario will cause a crash. There’s a fairly simple solution to a problem like this. When a closure is performing an asynchronous operation with an … ## 2. Unwrapping optionals Another issue I encounter commonly in code reviews is improper handling of optionals. Optionals take a type and wrap it in a special enumeration, which permits it to have a valid value of nil. For instance: ``` var a: Int // Compiler defaults to 0 var b: Int? // Compiler defaults to nil ``` … This is telling the compiler “I know that nil is a valid value for myObject, but I am 100% sure this will never be nil. Or if it is, I’m comfortable with this crashing.” I recommend this technique ONLY be used with IBOutlets in apps. IBOutlets expose properties to the Interface Builder tools inside Xcode. They are almost always references to view objects which will exist alongside a view controller or similar structure. Because of how IB files are inflated and wired to their controller counterparts, it’s not possible to make these outlets non-optional. As such, a common pattern is the following: … Note that this can be cumbersome for large data models and I definitely don’t recommend implementing this unless you absolutely have to. Because of all the messy try syntax, it’s easy to introduce an error that will be painful to debug. The rule to follow with `Codable` should be to setup only as simple as possible; let the Swift compiler do the heavy lifting.

### 2. The Other Side of Swift Having mentioned the pros, let’s discuss the disadvantages of Swift programming language. #### a. Still a Young Language There is no doubt that the language has progressed full-throttle, but it is still considered in its nascent stage, especially in comparison to Objective-C. This is why issues that need quick resolution crop up from time to time. Many of the available resources and tools dedicated to earlier Swift versions sometimes become incompatible with the newer releases. #### b. Very Few Native Libraries and Tools The notable downside of Swift — it still does not support enough native libraries. Although memory management may help developers with dynamic libraries, missing out on native libraries can be a mistake. The same problem lies with the native tools, making them highly dependent on third-party tools, leading to compatibility issues. … #### d. No Backwards Compatibility for SwiftUI SwiftUI can be deployed on iOS 13 or its succeeding versions. macOS requires a 10.15 version or later; for tvOS, it is 13 or later; for watchOS, the version should be 6 and above. This implies that Swift UI is not backward compatible as the newer features do not run smoothly with the older versions. #### e. Poor Compatibility with IDEs and Third-Party Tools As we mentioned before, by and large, there is an incompatibility with third-party tools because of frequent updates causing the older tool compatibility to go defunct. This makes it very difficult to find the right tools. Apple’s official IDE, Xcode, isn’t great for native tools and support. Apart from this, developers also face issues with compilers, syntax, highlighting, autocomplete, and even refactoring tools.

## 8. Hate: There is no natural way to create a design system If you are reusing a default value for padding, text size, etc, there's no real straightforward way to create a design system for that. We’ve looked at the following options: Using modifiers, but these need to be added on every single component. Creating extensions of the classes, but it’s a bit overkill and artificial to only add a few tiny cosmetic changes. Adding style constants in a centralized place and directly applying them where needed. ## 7. Love: Extensions Almost every code that lives in production has some class that’s been inflated beyond reasonable proportions. Especially when you’re working under tight deadlines like it was in our case. Swift's answer to this are extensions: chop your class into smaller parts based on whatever criteria you pick. In our case we’ve cut up a 1000+ line viewModel into bite-sized chunks of 200 lines based on responsibility. … ## 5. Hate: Preview in a legacy project The preview feature won't work on a project that has UIKit implemented. This is because it will need to build the whole project to create the preview, and even then it will sometimes give you errors related to pods. So if you are building SwiftUI over a UIKit project, you should not use the Preview View as it will only make your development slower. … ## 3. Hate: Lack of test support Even the most pragmatic programmer on our team, with more dirty tricks up his sleeve than there are duplicate questions on stackoverflow, was running out of ideas for testing certain functionality. Mocking parts of the code was often virtually impossible, even when using protocols. Unlike with javascript, where you can mock just about anything, with Swift you have to really code with testability in mind. … ## 1. Hate: Features unavailable for “lower” iOS versions We were very surprised that a simple feature like setting the focus on a Textfield via code was not supported in SwiftUI out-of-the-box (Basic support starts from iOS15 and up). The most bugs that we needed to solve revolved around using multiple modals in iOS14 for things such as alerts.

As for compilation time, you may think it's just a matter of optimisation. But the problem is that until those optimisation arrive, you can't rely too much on type inference (main source of slowdowns), which diminishes a lot the beauty of the code. Now that was for client side. Server side probably adds its share of issues. … Swift 2.2 + Xcode 7 wasn't great, but it was livable. Constraint SourceKit crashes makes Xcode essentially a text editor and not a good one. All indexing, highlighting essentially all IDE functionally lost. This is the worst development experience that I've seen in 20+ years as a developer. … I think the consensus is that we need nothing but bug fixes on the core stuff (Xcode, SourceKit, etc). ... But the compiler crashes and sourcekit instability are just breathtaking (even in 3.0+). I'm surprised I haven't seen this get more attention. I'd (somewhat) expected something like this for the first few releases, but two years in I'm starting to think the team bit off more than they can chew with the type system. ... The latter category is especially nasty, and SourceKit won't inform you of this, except perhaps to crash. Oh, and that dumb bar in Xcode. You can compile all the Swift source in your target successfully but have SourceKit choke on your build configuration. Accidentally introduce a duplicate set of headers in HEADER_SEARCH_PATHS? Degraded performance, and at worse, the compiler crashes everytime you edit text and SourceKit invokes the compiler. In cases like this the SOURCEKIT_LOGGING environment variable is your friend. Have fun combing through those logs to tease out what build option you set is causing your issue. … If these sorts of totally-indecisive deprecations were rare then you could overlook them, as otherwise Swift is a rather nice language. But they're everywhere. Even in trivial examples intended for beginners line after line of code gets the yellow deprecation warnings. "What does deprecated mean" was literally one of the first questions my girl asked me as she started out learning programming, which is ludicrous. You shouldn't be encountering deprecation warnings over and over when targeting a brand new platform using a teaching course barely a year old. … You didn't specify anything that says Swift isn't a "halfway decent programming language." ... It suffers from similar problems to Scala, where it tries to blend OO concepts in with FP concepts. Variance is where this flares up terribly because it doesn't provide any explicit support for covariance or contravariance. You end up with invariance and subtyping in a bunch of places which is not a nice combination. … Simple things like "a + b +...+ n" cause compile times to balloon exponentially, which means for arrays you end up refactoring concatenation of immutable arrays into a mutable array you call appendContentsOf on a bunch of times. SourceKit on the surface sounds great, but in truth it's a simple text parser that doesn't understand type aliases for example. The compiler _really_ struggles with anything beyond very simple generics, first the type inference starts to fail and then it'll refuse to compile until you break the code apart and add type ascriptions. The compile errors are often absolute nonsense, pointing nowhere near the actual errors or are like the Magic 8-ball coming up "ask again later". … As for compilation time, you may think it's just a matter of optimisation. But the problem is that until those optimisation arrive, you can't rely too much on type inference (main source of slowdowns), which diminishes a lot the beauty of the code. Now that was for client side. Server side probably adds its share of issues.

It's not perfect, but nothing else comes as close. One of the most prominent complaints - compile time explosion - really only happens in contrived examples where you're using a bunch of literals in one expression, which isn't realistic. However, it's stuck in a single ecosystem. And let's not talk about some of the newer frameworks. Oh, and Xcode is a joke. … TS to me is just an awkward patch on top of JS. It's really great! But only compared to JS. The mental model of its type system is difficult to form completely. But yes, Swift's tooling doesn't compare. Zanfa 6 months ago I know you should have defined validators for every single external API, library and database, but at some level it feels silly to do all of this extra work. … Right, but that's the problem - it's the only language I've used where this is something you have to worry about, and it's not like the type system is more powerful. And often, the issues stem from external libraries outside my control. Better compiler errors would help mitigate the issue. There's a lot to like about Swift, but I also think it's productive to identify the parts that compare unfavorably to other languages. ... "Why are tuple not Hashable ?!" Which means that you cannot have a tuple of Int `(1, 1)` as a key in a dict, and you have to make a struct that implement Hashable instead. And "Why do they not have a `.sum()` and I have to do `.reduce(0, +)` every time instead." … It's paradoxically high level with its syntax and ergonomics but is tied down to the same cross platform headaches like in low level languages (e.g. cpp). Linking across cross platforms requires lots of careful thought and testing. Unlike cpp, it's not super portable. It requires a hefty 30 MB runtime for some features of the language to work. Try static executable hello world.

### Lack of Libraries and Frameworks One of the major challenges faced by Swift developers is the limited availability of third-party libraries and frameworks compared to more mature languages like Java or Python. This can make it difficult for developers to quickly build complex features and functionalities without having to reinvent the wheel. … ### Debugging and Performance Optimization Debugging and optimizing performance are essential aspects of software development, and Swift developers often face challenges in these areas due to the language's strict type system and memory management model. Identifying and resolving bugs and performance issues can be time-consuming and require a deep understanding of Swift's internals. … ### Compatibility and Versioning As a rapidly evolving language, Swift is regularly updated with new features, improvements, and bug fixes. While this is beneficial in terms of keeping the language modern and competitive, it can also pose challenges for developers in terms of compatibility and versioning. - To address compatibility issues, developers should stay informed about the latest changes in Swift and regularly update their codebase to accommodate new language features and syntax. ... - Versioning can also be challenging, particularly when working on projects with multiple team members or dependencies on external libraries. Implementing a robust version control system, such as Git, and following best practices for dependency management can help streamline the versioning process and mitigate potential conflicts. … ### Understanding Swift's Syntax and Features One of the biggest challenges faced by developers new to Swift is understanding its syntax and features. Swift was designed to be more concise and readable than Objective-C, but this can also make it more complex for beginners. Developers coming from other programming languages may find it challenging to adapt to Swift's syntax, which includes features like optionals, generics, and closures. … ### Optimizing Performance and Memory Management Performance and memory management are critical aspects of Swift development, particularly when working on resource-intensive applications. Swift's automatic memory management system helps developers avoid common memory leaks and crashes, but optimizing performance can still be a challenge for developers. A recent study by JetBrains revealed that Swift developers value performance and efficiency as the top factors when choosing a programming language. This underscores the importance of mastering performance optimization and memory management techniques to deliver high-quality Swift applications. ### Keeping Up with Updates and New Features Swift is a rapidly evolving language, with new updates and features introduced regularly by Apple. While these updates bring improvements and new capabilities to Swift, they can also pose a challenge for developers in keeping up with the latest changes. According to the 2024 State of Developer Ecosystem report by JetBrains, Swift is among the top 10 programming languages with the highest growth rate. This rapid growth highlights the need for developers to stay updated on new features and best practices to leverage the full potential of Swift in their projects. … ### Compatibility Issues One of the biggest challenges faced by Swift developers is compatibility issues. As Swift is a relatively new language, there are often compatibility issues between different versions of Swift and with third-party libraries. This can lead to frustrating bugs and errors that can be difficult to debug. To overcome compatibility issues, developers should regularly update their Swift code to the latest version of the language. Apple releases updates to Swift regularly, and staying up-to-date with these updates can help prevent compatibility issues. Additionally, developers should carefully test their code with different versions of Swift and third-party libraries to ensure compatibility. ### Lack of Experience Another common challenge for Swift developers is a lack of experience with the language. Swift is a relatively new language, and many developers may not have had the opportunity to work with it extensively. This can make it difficult to write efficient, bug-free code. To overcome this challenge, developers should take the time to learn Swift thoroughly. There are many online resources, tutorials, and courses available that can help developers improve their Swift skills. Additionally, developers should practice writing code in Swift regularly to build their proficiency with the language. ### Performance Issues Performance issues can also be a significant challenge for Swift developers. Developing high-performance iOS apps requires careful attention to detail and optimization. Poorly optimized code can lead to slow app performance, crashes, and bad user experiences. To address performance issues, developers should pay close attention to memory management, code efficiency, and app architecture. Using tools like Instruments can help developers identify performance bottlenecks and optimize their code for better performance. Additionally, developers should test their apps on a variety of devices to ensure optimal performance across different hardware configurations. … } Another challenge is dealing with compatibility issues between different versions of Swift and Xcode. It can be a headache trying to make sure your code works across all platforms and devices. One big issue I've encountered is the lack of proper error handling in Swift. There are times when the compiler doesn't catch certain errors, leading to crashes or unexpected behavior at runtime. <code> do { try someFunction() } catch { print(An error occurred: \(error)) } A common problem is dealing with memory management in Swift.

And the lack of namespaces. I *so* would like C#-style namespaces. And the lack of namespaces. I "Hate" wasn't actually that powerful a word in this context because it wasn't literal. But now the word "strongly" is here, so it's more accurate, but also more negative. - Using Swift in Xcode is just unpleasant. The compiler is slow, the debugger breaks far more often than it works, and the app overall just has too much focus on annual new Features they can trot out on a WWDC keynote slide, and not enough emphasis on the fundamental developer experience. sourcekit-lsp does not yet seem to be reliable enough for a user of VSCode or vim or whatever to be able to have their project Just Work without fussing. - Building any large project effectively requires a lot of excessive modularization (which means a lot of developer time on overhead spent on modules). - Unit testing not allowing access to private members. "But you're supposed to test the API, not the internals" is an idea that doesn't work when you need to be able to write a test for a bug fix, or for feature flagging, or whatever. I have to bend my code into pretzels adding nonsense to an interface to test things in Swift, and it is a significant waste of time that would be avoidable if I could just test a private variable. - Also in JavaScript land, you can set up your unit tests to run in real-time when you change files. That would be nice to have. Especially if tests could live alongside files, rather than in a separate module because that's how Objective-C decided to do it 20 years ago. Agree here, though to be fair the server-side Swift experience seems smoother overall, at least debugging is faster and more reliable. Swift's awkwardness on iOS (and macOS?) is likely coming from the fact that it should deal with a few gigantic ObjC frameworks. I’m sure I could think of a list of annoyances about Swift as a language but I can’t think of a single annoyance about the language that harms my productivity more than what Steve mentioned a few posts up…the compiler speed and Xcode performance. Yes, I know Xcode isn’t Swift and so I guess this is off topic, but honestly most people write Swift code in Xcode and the developer experience has got steadily worse over recent years. Whilst I can recognise some of the improved features in Xcode is is slow, buggy and unstable. The last few releases have been particularly terrible for crashes and the Xcode release cycle is too long. Can we have a “snow leopard” release for Xcode please? i would agree that this is one of the largest things bottlenecking my productivity, but i am not sure what, if anything, could possibly be done about the compilation speed. personally i have made peace with the compile times. i suppose it is one of the necessary tradeoffs of using a language that tries to be expressive and performant at the same time. Absolutely agree. Making enums, when you just need a namespace, makes me sad It must be very difficult to implement the “.” command in Xcode. That’s why it’s not implemented. It’s not vi without this. I really love vim mode because I know vi from so long ago my finger just do it without thinking. But when things do not work, it’s WTF! … Lack of abstract classes once was a big challenge for me. I had a use case where clients must inherit implementation from the base class provided by the framework, and they must implement few abstract methods. I was lucky in my case to be able to decompose into concrete base class and protocol, but resulting generic signatures were complicated, required a lot of experiments to figure out, and were crashing compiler from time to time. … community-provided vim extension supports it perfectly, plus many other non-trivial vim features (like macros). That's why I really wish that Apple would work on providing a safe plugin API, so that the community could solve all of these problems themselves, and they could work on other things, instead of re-implementing vim inside Xcode. Not being able to to declare **static variables** within a **function**. The only option is to litter the app with globals. … Then I'll rephrase my "dislike"... Not being able to declare a **thread safe long-living local variable** within a **function**. I know we can do this, but I don't know if its thread safe.

They also can’t be automatically updated since they’re stuck in the version you compiled at. **Dynamic ** libraries, on the other hand, exist outside of your code and are uploaded only when needed. Static libraries need to have copies in all files of your program while dynamic ones only need one. Swift first introduced dynamic libraries to iOS when it launched. … But, at the same time, these steps, i.e., frequent updates and changes, often make developers doubt if their today’s code will be compatible with previous versions tomorrow and if their project can be compiled at all. ### Limited talent pool While the Swift community is growing fast, it is still significantly smaller as compared to any other open source language. According to the latest StackOverflow Developer Survey, only 5.1 percent of the 83,053 respondents use Swift. It means that if you decide to create your next project using Swift, you might struggle with finding developers that are experienced enough with it. … ### Poor interoperability with third-party tools and IDEs Largely due to frequent updates, as mentioned above, it is often hard to find the right tools to help with certain tasks. Moreover, the official Apple IDE, XCode, lags in terms of tooling and support for Swift. Developers often report issues with syntax highlighting, autocomplete, refactoring tools, and compilers. ### Incomplete cross-platform support As we mentioned earlier, Swift supports all Apple platforms, as well as Linux and Windows. However, it was originally created and still works best for native iOS development, leaving the cross-platform market to React Native, Xamarin, and Flutter. ### Lack of support for earlier iOS versions You can only use Swift in the apps that target iOS7 and later. That said, Swift can’t be used for legacy projects running on older versions of the operating system. It’s not that significant since only a tiny percent of Apple devices currently run on iOS6 or earlier versions, but you still have to keep that in mind, you know, just in case.